root/as3/gunyarapaint/trunk/gunyarapaint/src/org/libspark/gunyarapaint/entities/GPPen.as

package org.libspark.gunyarapaint.entities
{
  import flash.display.BlendMode;
  import flash.display.CapsStyle;
  import flash.display.Graphics;
  import flash.display.JointStyle;
  import flash.display.LineScaleMode;
  import flash.display.Shape;
  import flash.events.MouseEvent;
  import flash.geom.Point;
  
  import mx.controls.Alert;
  
  import org.libspark.gunyarapaint.controls.GPCanvas;
  import org.libspark.gunyarapaint.controls.GPCanvasWindowControl;
  import org.libspark.gunyarapaint.controls.PenDetailControl;

  public class GPPen
  {
    [Embed(source="../../../../../imgs/icon_dropper.png")] private var dropperIcon:Class;
    [Embed(source="../../../../../imgs/icon_hand_open.png")] private var handOpenIcon:Class;
    [Embed(source="../../../../../imgs/icon_hand_close.png")] private var handCloseIcon:Class;

    public static const PEN_MODE_HAND:uint = 1;
    public static const PEN_MODE_DROPPER:uint = 2;
    public static const PEN_MODE_LINE:uint = 3;
    public static const PEN_MODE_RECT:uint = 4;
    public static const PEN_MODE_ELLIPSE:uint = 5;
    public static const PEN_MODE_ROUND_RECT:uint = 6;
    public static const PEN_MODE_FLOOD_FILL:uint = 7;
    public static const PEN_MODE_HANDTOOL:uint = 8;
    public static const PEN_MODE_ERASER:uint = 9;

    private var _mode:uint;

    private var _thickness:uint;
    private var _color:uint;
    private var _alpha:Number;
    private var _blendMode:String;
    private var _scaleMode:String;
    private var _capsStyle:String;
    private var _jointStyle:String;
    private var _miterLimit:Number;
    private var _pixelHinting:Boolean;

    private var _canvas:GPCanvas;
    private var _canvasWindow:GPCanvasWindowControl;
    private var _control:PenDetailControl;

    private var _drawShape:Shape; // 描画用Shape
    private var _previewShape:Shape; // プレビュー用Shape(直線とか)
    private var _layers:GPLayerArray;
    
    public function get mode():uint {
      return _mode;
    }
    public function get thickness():uint {
      return _thickness;
    }
    public function get color():uint {
      return _color;
    }
    public function get alpha():Number {
      return _alpha;
    }
    public function get blendMode():String {
      return _blendMode;
    }
    public function get scaleMode():String {
      return _scaleMode;
    }
    public function get capsStyle():String {
      return _capsStyle;
    }
    public function get jointStyle():String {
      return _jointStyle;
    }
    public function get miterLimit():Number {
      return _miterLimit;
    }
    public function get pixelHinting():Boolean {
      return _pixelHinting;
    }
    public function get argbColor():uint {
      return uint(_alpha * 255) << 24 | _color;
    }
    public function get argbRGBColor():uint {
      return 0xFF000000 | _color;
    }
    public function get drawShape():Shape {
      return _drawShape;
    }

    public function GPPen(thickness:uint = 3,
                          color:uint = 0x000000,
                          alpha:Number = 1,
                          blendMode:String = flash.display.BlendMode.NORMAL,
                                scaleMode:String = LineScaleMode.NORMAL,
                                capsStyle:String = CapsStyle.ROUND,
                                jointStyle:String = JointStyle.ROUND,
                                miterLimit:Number = 3,
                                pixelHinting:Boolean = true,
                                mode:uint = PEN_MODE_HAND) {
        this.thickness = thickness;
        this.color = color;
        this.alpha = alpha;
        this.blendMode = blendMode;
        this.scaleMode = scaleMode;
        this.capsStyle = capsStyle;
        this.jointStyle = jointStyle;
        this.miterLimit = miterLimit;
        this.pixelHinting = pixelHinting;
        this.mode = mode;
        _drawShape = new Shape();
        _previewShape = new Shape();
    }
    
    public function clone():GPPen {
      return new GPPen(thickness, color, alpha, blendMode, scaleMode, capsStyle, jointStyle, miterLimit, pixelHinting, mode);
    }

        public function setLineStyle(shape:Shape):void {
      shape.graphics.lineStyle(_thickness,
                               _color,
                               _alpha,
                               _pixelHinting,
                               _scaleMode,
                               _capsStyle,
                               _jointStyle,
                               _miterLimit);

      shape.blendMode = _blendMode;
        }
            
    public function set mode(v:uint):void {
      _mode = v;
      if (_canvas) {
        switch (mode) {
        case PEN_MODE_DROPPER:
          _canvas.setCursor(dropperIcon);
          break;
        case PEN_MODE_HANDTOOL:
          _canvas.setCursor(handOpenIcon);
          break;
        case PEN_MODE_ERASER:
           // FIXME: give me eraser icon
          _canvas.setCursor(null);
          break;
        default:
          _canvas.setCursor(null);
        }
        if (mode == PEN_MODE_DROPPER) {
        } else {
        }        
      }
    }
    public function set thickness(v:uint):void {
      if (v > 32) {
        // TODO: alert
        return;
      }
      _thickness = v;
    }
    
    public function set color(v:uint):void {
      _color = v;
      if (_control) {
        _control.penColorChangeHandler();
      }
    }
    public function set alpha(v:Number):void {
      _alpha = v;
    }
    public function set blendMode(v:String):void {
      _blendMode = v;
    }
    public function set scaleMode(v:String):void {
      _scaleMode = v;
    }
    public function set capsStyle(v:String):void {
      _capsStyle = v;
    }
    public function set jointStyle(v:String):void {
      _jointStyle = v;
    }
    public function set miterLimit(v:Number):void {
      _miterLimit = v;
    }
    public function set pixelHinting(v:Boolean):void {
      _pixelHinting = v;
    }
    
    public function set canvas(c:GPCanvas):void {
      _canvas = c;
    }
    public function set canvasWindow(cw:GPCanvasWindowControl):void {
      _canvasWindow = cw;
    }
    public function set control(c:PenDetailControl):void {
      _control = c;
    }
    public function get drawGraphics():Graphics {
      return _drawShape.graphics;
    }
    public function set layers(l:GPLayerArray):void {
      _layers = l;
    }
    
    private var fromPoint:Point = new Point();
    private var scrollBase:Point;
    private var isMouseDownAndOut:Boolean = false;
    
    public function mouseDown(evt:MouseEvent):void {
      // 一応…
      if (!_canvas.isInCanvas(evt)) {
        return;
      }
          switch (mode) {
            case PEN_MODE_HAND:
            case PEN_MODE_ERASER:
              // moveToして、ペンの状態を設定し、ペンの状態変化をログし、始点の座標を覚えさせる
              // FIXME: lintToまでmoveToを遅延させよう！
        if (!_canvas.isTargetLayerVisible) {
          Alert.show('不可視の状態では描画できません！', '手書き/消しゴムツール');
          return;
        }
        if (_canvas.isTargetLayerLocked) {
          Alert.show('ロックされています！', '手書き/消しゴムツール');
          return;
        }
              _canvas.moveTo(evt.localX, evt.localY);
              break;
            case PEN_MODE_LINE:
            case PEN_MODE_RECT:
            case PEN_MODE_ELLIPSE:
            case PEN_MODE_ROUND_RECT:
        if (!_canvas.isTargetLayerVisible) {
          Alert.show('不可視の状態では描画できません！', '描画ツール');
          return;
        }
        if (_canvas.isTargetLayerLocked) {
          Alert.show('ロックされています！', '描画ツール');
          return;
        }
              fromPoint.x = evt.localX;
              fromPoint.y = evt.localY;     
        break;
            case PEN_MODE_HANDTOOL:
              fromPoint.x = Math.floor(evt.localX); fromPoint.y = Math.floor(evt.localY);
              scrollBase = _canvasWindow.canvasScrollPosition;
        break;
      case PEN_MODE_DROPPER:
        color = _canvas.getColor(evt);
        break;
      case PEN_MODE_FLOOD_FILL:
        if (!_canvas.isTargetLayerVisible) {
          Alert.show('不可視の状態では描画できません！', 'バケツツール');
          return;
        }
        if (_canvas.isTargetLayerLocked) {
          Alert.show('ロックされています！', 'バケツツール');
          return;
        }
              _canvas.moveTo(evt.localX, evt.localY);
        _canvas.floodFill();
        break;
          }
    }

    public function mouseMove(evt:MouseEvent):void {
      if (evt.buttonDown) {
        switch (mode) {
              case PEN_MODE_HAND:
              case PEN_MODE_ERASER:
          if (_canvas.isInCanvas(evt)) {
            if (_canvas.isMoveTo) {
              _canvas.lineTo(evt.localX, evt.localY);
            } else {
              // マウス押しっぱなしで領域内にはいってきた場合
              ; // 今は何もしない
            }
          } else {
            // TODO: 直線と枠との交点を座標とする。
            return;
          }
          break;
        case PEN_MODE_DROPPER:
          if (_canvas.isInCanvas(evt)) {
            color = _canvas.getColor(evt);
          }
          break;
        case PEN_MODE_HANDTOOL:
          if (scrollBase) {
            _canvasWindow.scrollCanvas(scrollBase.x + (fromPoint.x - evt.localX),
                                       scrollBase.y + (fromPoint.y - evt.localY));
            //trace('base x:' + scrollBase.x + ' y:' + scrollBase.y + ' from x:' + fromPoint.x + ' y:' + fromPoint.y + ' local x:' + evt.localX + ' y:' + evt.localY + ' diff x:' + (fromPoint.x - evt.localX) + ' y:' + (fromPoint.y - evt.localY));            
          }
          break;
        case PEN_MODE_LINE:
          previewLineTo(fromPoint.x, fromPoint.y, evt.localX, evt.localY);
          break;
        }
      }
    }
    public function mouseUp(evt:MouseEvent):void {
      switch (mode) {
      case PEN_MODE_HAND:
      case PEN_MODE_ERASER:
        if (!_canvas.isDrawnLine) {
          var tmpAlpha:Number = alpha;
          alpha = 0;
          _canvas.setAndLogLineStyle();
          _canvas.beginFill(color, tmpAlpha);
          _canvas.drawCircle(thickness / 2);
          _canvas.endFill();
          alpha = tmpAlpha;
        }
        _canvas.drawShapeOnBitmap();
        break;
      case PEN_MODE_LINE:
        if (!GPCanvas.comparePoint(fromPoint.x, fromPoint.y, evt.localX, evt.localY)) {
          // 始点と終点が違う場合にのみ線を引く
          clearPreviewShape();
          _canvas.moveTo(fromPoint.x, fromPoint.y);
          _canvas.lineTo(evt.localX, evt.localY);
          _canvas.drawShapeOnBitmap();          
        }
        break;
      case PEN_MODE_DROPPER:
        if (_control) {
          _control.cancelTool();
        }
        break;
      case PEN_MODE_HANDTOOL:
        scrollBase = null;
        break;
      }
    }
    
    // stage全体でmouseUpがあった場合。
    // mouseUpと二重で呼ばれる場合があるので注意
    public function extMouseUp():void {
    }
    
    public function mouseOut(evt:MouseEvent):void {
      switch (mode) {
      case PEN_MODE_HAND:
        // 外に出ても１mouseUpとかはしない
        break;
      case PEN_MODE_LINE:
        clearPreviewShape();
        break;
      }
    }
    // イベントハンドラおわり
    
    // previewShape系    
        public function clearPreviewShape():void {
          _previewShape.graphics.clear();
        }
        
        public function previewLineTo(fromX:Number, fromY:Number, toX:Number, toY:Number):void {
          _previewShape.graphics.clear();
          setLineStyle(_previewShape);
          _previewShape.graphics.moveTo(GPCanvas.zz(fromX), GPCanvas.zz(fromY));
          _previewShape.graphics.lineTo(GPCanvas.zz(toX), GPCanvas.zz(toY));
        }
  }
}