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

// 今考えると、このクラス全体的に設計がおかしい。
// 定数持っているなら、それを外部から指定してもらうべきだし、
// 読み込みのswitchは同じような処理を２回やって無駄だ。

package org.libspark.gunyarapaint.entities
{
  import flash.display.BitmapData;
  import flash.errors.EOFError;
  import flash.events.MouseEvent;
  import flash.geom.Point;
  import flash.utils.ByteArray;
  
  import mx.controls.Alert;
  import mx.core.Application;
  import mx.utils.Base64Decoder;
  import mx.utils.Base64Encoder;
  
  import org.libspark.gunyarapaint.controls.GPCanvas;
  import org.libspark.gunyarapaint.controls.GPCanvasWindowControl;
  import org.libspark.gunyarapaint.controls.GPLayerWindowControl;
  import org.libspark.gunyarapaint.controls.PenDetailWindowControl;
  
  public class GPLogger
  {
    [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;

    // 座標差分計算用
    private var preX:uint, preY:uint;
    private var preAction:String = ''; 
    
    private var _logCount:uint; // ログのイベント数
    private var _log:ByteArray; // 圧縮されていない状態を保持
    private var _canvasWidth:uint, _canvasHeight:uint; // キャンバスサイズ
    private var _undoBufferSize:uint; // アンドゥバッファサイズ
    private var _startLogPosition:uint; // ログのヘッダを読み終えた後の位置
    private var _baseLayers:BitmapData; // 基となる絵
    private var _baseInfo:Object; // 基となる絵のメタ情報
    
    private var _changeUndoRedoHandler:Function;

    // 各種エンティティたち
    private var _canvas:GPCanvas; // 大本のGPCanvas

    // 互換性。つか、過去のバグやマズった設計で作られたログについてちゃんと再生できるようにする。
    public var compatibility_0_0_1:Boolean = false;

    public function GPLogger(log:ByteArray,
                             onLogging:Boolean,
                             canvasWidth:uint,
                             canvasHeight:uint,
                             undoBufferSize:uint,
                             baseLayers:BitmapData,
                             baseInfo:Object
                            ):void {

      // ログは、ヘッダ部分を飛ばしたところにカーソルが当たっていることを前提としている
      // あと、BIG_ENDIANね。
      _log = log;
      _onLogging = onLogging;
      _canvasWidth = canvasWidth;
      _canvasHeight = canvasHeight;
      _undoBufferSize = undoBufferSize;
      _baseLayers = baseLayers;
      _baseInfo = baseInfo;
      
      var app:Object = Application.application;
      try {
        _canvasWindow = app.gpCanvasWindow;
        _penWindow = app.penDetailWindow;
        _layerWindow = app.gpLayerWindow;
        _changeUndoRedoHandler = app.changeUndoRedoHandler;
      } catch (e:ReferenceError) {
        _canvasWindow = null;
        _penWindow = null;
        _layerWindow = null;
        _changeUndoRedoHandler = function (u:uint, r:uint):void {};
      }
      _startLogPosition = _log.position;
    }

    // グローバルイベントハンドラ・変数としてのloggerをみんなに配る
    public function createCanvas():void {
      _layerArray = GPLayerArray.createFromLayersImageInfo(this, _baseLayers, _baseInfo);
      if (_onLogging) {
        _canvas = new GPCanvas(this);
      }
      _pen = new GPPen(this);
      _undoBuffer = new GPUndoBuffer(this);
      if (_canvasWindow) {
        _canvasWindow.logger = this;
      }
      if (_penWindow) {
        _penWindow.logger = this;
      }
      if (_layerWindow) {
        _layerWindow.logger = this;
      }
    }

    // 再生用・ふっかつのじゅもん用
    public static function createFromByteArray(log:ByteArray,
                                               onLogging:Boolean,
                                               baseLayers:BitmapData,
                                               baseInfo:Object
                                              ):GPLogger {
      log.endian = flash.utils.Endian.BIG_ENDIAN;
      var buf:String = log.readUTFBytes(14);
      if (buf != 'GUNYARA_PAINT:') {
        Alert('不正なお絵カキコのログです。');
        return null;
      }
      buf = log.readUTFBytes(6);
      var width:uint = log.readShort();
      var height:uint = log.readShort();
      var undoBufferSize:uint = log.readShort();

      var ret:GPLogger = new GPLogger(log, onLogging, width, height, undoBufferSize, baseLayers, baseInfo);
      switch (buf) {
      case '0.0.1:':
        ret.compatibility_0_0_1 = true;
        break;
      case '0.0.2:': // 0.5ずれバグの修正、ドット描画バグの修正
      case '0.0.3:': // レイヤ対応初版、最初の数点は0.0.2versionでレイヤのやつがある
      case '0.0.4:':
      case '0.0.5:':
      case '0.0.6:':
      case '0.0.7:':
      case '0.0.8:': // undo時のために、GPLayerでの描画時にbitmapDataをcloneするように、
                       // & レイヤの可視・不可視をundoバッファに積まないようにする。
      case '0.0.9:': // ドット絵ペン追加、lineTo/ドット絵で無駄なログが出ないように
      case '0.1.0:': // レイヤー統合のUndoでbitmapDataをcloneしていなかった問題を修正
                       // mergeWithBelowの実装を変えて、統合後のalpha値を1に設定するようにした。
        break;
      default:
        Alert('このバージョンのログには対応しておりません。ブラウザをリロードしてみてください。');
        return null;
      }
      ret.createCanvas();
      return ret;
    }
    
    // 描画用
    public static function createForDraw(width:uint, height:uint,
                                         undoBufferSize:uint,
                                         baseLayers:BitmapData,
                                         baseInfo:Object
                                        ):GPLogger {
      var log:ByteArray = new ByteArray();
      log.endian = flash.utils.Endian.BIG_ENDIAN;
      log.writeUTFBytes('GUNYARA_PAINT:0.1.0:');
      log.writeShort(width);
      log.writeShort(height);
      log.writeShort(undoBufferSize);
      var ret:GPLogger = new GPLogger(log, true, width, height, undoBufferSize, baseLayers, baseInfo);
      ret.createCanvas();

      return ret;
    }


    // ACTIONは6bit長 0x3fまで
    public static const ACTION_NONE:uint = 0;
    public static const ACTION_MOVETO:uint = 1;
    public static const ACTION_LINETO:uint = 2;
    public static const ACTION_LINESTYLE:uint = 3;
    public static const ACTION_DRAW_SHAPE_ON_BITMAP:uint = 4;
    public static const ACTION_UNDO:uint = 5;
    public static const ACTION_REDO:uint = 6;
    public static const ACTION_BEGIN_FILL:uint = 7;
    public static const ACTION_END_FILL:uint = 8;
    public static const ACTION_DRAW_RECT:uint = 9;
    public static const ACTION_DRAW_CIRCLE:uint = 10;
    public static const ACTION_DRAW_ELLIPSE:uint = 11;
    public static const ACTION_DRAW_ROUND_RECT:uint = 12;
    public static const ACTION_FLOOD_FILL:uint = 13;
    public static const ACTION_LAYER_NEW:uint = 14;
    public static const ACTION_LAYER_COPY:uint = 15;
    public static const ACTION_LAYER_SWAP:uint = 16;
    public static const ACTION_LAYER_MERGE_WITH_BELOW:uint = 17;
    public static const ACTION_LAYER_REMOVE:uint = 18;
    public static const ACTION_LAYER_CHANGE_TARGET:uint = 19;
    public static const ACTION_LAYER_CHANGE_VISIBLE:uint = 20;
    public static const ACTION_LAYER_CHANGE_BLEND_MODE:uint = 21;
    public static const ACTION_LAYER_CHANGE_ALPHA:uint = 22;
    public static const ACTION_SET_PIXEL:uint = 23;

    // LINESTYLE
    public static const LINESTYLE_THICKNESS:uint = 1;
    public static const LINESTYLE_COLOR:uint = 2;
    public static const LINESTYLE_ALPHA:uint = 3;
    public static const LINESTYLE_BLEND_MODE:uint = 4;
    public static const LINESTYLE_SCALE_MODE:uint = 5;
    public static const LINESTYLE_CAPS:uint = 6;
    public static const LINESTYLE_JOINTS:uint = 7;
    public static const LINESTYLE_MITER_LIMIT:uint = 8;
    public static const LINESTYLE_PIXEL_HINTING:uint = 9; // NB: not used! first version, this is true

    private var _pen:GPPen;
    private var _layerArray:GPLayerArray;
    private var _undoBuffer:GPUndoBuffer;

    private function pushUndoBuffer():void {
      _undoBuffer.push(_layerArray);
      _changeUndoRedoHandler(_undoBuffer.undoCount, _undoBuffer.redoCount);
    }

    public function drawShapeOnBitmap():void {
      _layerArray.draw(_pen.drawShape, null, null, _pen.blendMode, null, false);
      pushUndoBuffer();
      invokeRemoveDrawLayer();
    }
    
    private function invokeInsertDrawLayer():void {
      _pen.setLineStyle();
      _layerArray.insertDrawLayer(_pen.drawShape, _pen);      
    }
    
    private function invokeRemoveDrawLayer():void {
      _layerArray.removeDrawLayer(_pen.drawShape);
      _pen.clearDrawShape();
    }

    /** log write **/

    private function writeByte(byte:int):void {
      _log.writeByte(byte);
    }
    private function writeShort(value:int):void {
      _log.writeShort(value);
    }
    private function writeUInt(value:uint):void {
      _log.writeUnsignedInt(value);
    }
    private function writeDouble(value:Number):void {
      _log.writeDouble(value);
    }
    private function writeUTF(value:String):void {
      _log.writeUTF(value);
    }
    private function writeBoolean(value:Boolean):void {
      _log.writeByte(value ? 1 : 0);
    }
    private function readByte():uint {
      return _log.readUnsignedByte();
    }
    private function readShort():int {
      return _log.readShort();
    }
    private function readUShort():uint {
      return uint(_log.readShort() & 0xffff);
    }
    private function readUInt():uint {
      return _log.readUnsignedInt();
    }
    private function readDouble():Number {
      return _log.readDouble();
    }
    private function readUTF():String {
      return _log.readUTF();
    }
    private function readBoolean():Boolean {
      return (_log.readByte() == 1);
    }

    // ログ関係のローカル変数
    private var _playLogIntervalId:uint;
    private var _playSpeed:uint;

    public function set playSpeed(speed:uint):void {
      _playSpeed = speed;
    }
    
    private var _playCompleteCallback:Function;

    public function play(speed:uint, callback:Function):void {
      _playSpeed = speed;
      _playCompleteCallback = callback;
      _playLogIntervalId = flash.utils.setInterval(playNext, 50);
    }

    private var _preAction:uint = ACTION_NONE; // for avoid version 0.0.1 bug...◆
    private function playNext():void {
      for (var i:uint = 0; i < _playSpeed; i++) {
        if (!read()) {
          flash.utils.clearInterval(_playLogIntervalId);
          _playCompleteCallback();
          break;
        }
        if (_layerArray.view.numChildren != _layerArray.length) {
          // check logic
        }
      }
    }
    
    public function read():Boolean {
      var byte:uint;
      var dx:int, dy:int;
      var short:uint;

      var uintNum:uint;
      var uintNum2:uint;
      var str:String;
      var doubleNum:Number;
      var bool:Boolean;
      
      try {
        byte = readByte();

/*
        if (compatibility_0_0_1 &&
            _preAction == GPLogger.ACTION_MOVETO && action != GPLogger.ACTION_LINETO) {
          _pen.drawOldBugPointRect();
        }
*/

        switch (byte) {
        case ACTION_MOVETO:
          dx = readShort();
          dy = readShort();
          preX += dx;
          preY += dy;
          eventMoveTo(preX, preY);
          break;
        case ACTION_LINETO:
          dx = readShort();
          dy = readShort();
          preX += dx;
          preY += dy;
          eventLineTo(preX, preY);
          break;
        case ACTION_LINESTYLE:
          dx = readByte(); // style type
          switch (dx) {
          case GPLogger.LINESTYLE_THICKNESS:
            uintNum = readByte();
            eventLineStyleThickness(uintNum);
            break;
          case GPLogger.LINESTYLE_COLOR:
            uintNum = readUInt();
            eventLineStyleColor(uintNum);
            break;
          case GPLogger.LINESTYLE_ALPHA:
            doubleNum = readDouble();
            eventLineStyleAlpha(doubleNum);
            break;
          case GPLogger.LINESTYLE_MITER_LIMIT:
            doubleNum = readDouble();
            eventLineStyleMiterLimit(doubleNum);
            break;
          case GPLogger.LINESTYLE_BLEND_MODE:
            str = readUTF();
            eventLineStyleBlendMode(str);
            break;
          case GPLogger.LINESTYLE_SCALE_MODE:
            str = readUTF();
            eventLineStyleScaleMode(str);
            break;
          case GPLogger.LINESTYLE_CAPS:
            str = readUTF();
            eventLineStyleCapsStyle(str);
            break;
          case GPLogger.LINESTYLE_JOINTS:
            str = readUTF();
            eventLineStyleJointStyle(str);
            break;
          case GPLogger.LINESTYLE_PIXEL_HINTING:
            bool = readBoolean();
            eventLineStylePixelHinting(bool);
            break;
          default:
            Alert.show('未対応のラインスタイルです。');
            break;
          }
          break;
        case ACTION_DRAW_SHAPE_ON_BITMAP:
          eventDrawShapeOnBitmap();
          break;
        case ACTION_UNDO:
          eventUndo();
          break;
        case ACTION_REDO:
          eventRedo();
          break;
        case ACTION_BEGIN_FILL:
          uintNum = readUInt();
          doubleNum = readDouble();
          eventBeginFill(uintNum, doubleNum);
          break;
        case ACTION_END_FILL:
          eventEndFill();
          break;
        case ACTION_DRAW_CIRCLE:
          doubleNum = readDouble();
          eventDrawCircle(doubleNum);
          break;
        case ACTION_FLOOD_FILL:
          eventFloodFill();
          break;
        case ACTION_LAYER_NEW:
          eventLayerNew();
          break;
        case ACTION_LAYER_COPY:
          eventLayerCopy();
          break;
        case ACTION_LAYER_SWAP:
          uintNum = readByte();
          uintNum2 = readByte();
          eventLayerSwap(uintNum, uintNum2);
          break;
        case ACTION_LAYER_MERGE_WITH_BELOW:
          eventLayerMergeWithBelow();
          break;
        case ACTION_LAYER_REMOVE:
          eventLayerRemove();
          break;
        case ACTION_LAYER_CHANGE_TARGET:
          uintNum = readByte();
          eventLayerChangeTarget(uintNum);
          break;
        case ACTION_LAYER_CHANGE_VISIBLE:
          uintNum = readByte();
          bool = readBoolean();
          eventLayerChangeVisible(uintNum, bool);
          break;
        case ACTION_LAYER_CHANGE_BLEND_MODE:
          str = readUTF();
          eventLayerChangeBlendMode(str);
          break;
        case ACTION_LAYER_CHANGE_ALPHA:
          doubleNum = readDouble();
          eventLayerChangeAlpha(doubleNum);
          break;
        case ACTION_SET_PIXEL:
          uintNum = readShort();
          uintNum2 = readShort();
          eventSetPixel(uintNum, uintNum2);
          break;
        default:
          if (byte & 0x80) {
            if (byte & 0x40) {
              // 7bit lineTo
              _log.position -= 1;
              short = readShort();
              dx = (short << 18) >> 25;
              dy = (short << 25) >> 25;
            } else {
              // 3bit lineTo
              dx = (byte << 26) >> 29;
              dy = (byte << 29) >> 29;
            }
            preX += dx;
            preY += dy;
            eventLineTo(preX, preY);
          } else if (byte & 0x40) {
            // 7bit moveTo
            _log.position -= 1;
            short = readShort();
            dx = (short << 18) >> 25;
            dy = (short << 25) >> 25;
            preX += dx;
            preY += dy;
            eventMoveTo(preX, preY);
          } else {
            Alert.show('未対応のアクションです。');
            // error
          }
        }
        _preAction = byte;
        return true;
      } catch (e:EOFError) {
      }
      return false;
    }

    public function resetInstance():void {
      _log.position = _startLogPosition;
      preX = 0; preY = 0; _logCount = 0;
    }

    public function get password():String {
      var pos:uint = _log.position;
      var e:Base64Encoder = new Base64Encoder();
      _log.compress();
      e.encodeBytes(_log);
      _log.uncompress();
      _log.position = pos;
      return e.flush();
    }
    
    public static function deserialize(s:String,
                                       changeImageCallback:Function,
                                       undoRedoCallback:Function,
                                       baseLayers:BitmapData,
                                       baseInfo:Object
                                      ):GPLogger {
      var e:Base64Decoder = new Base64Decoder();
      e.decode(s);
      var b:ByteArray = e.toByteArray();
      b.uncompress();
      return createFromByteArray(b, true, baseLayers, baseInfo);
    }

    /**********************************************/
    /* 新メソッド */
    private var _preX:int, _preY:int; // ログで差分エンコードするときに必要な直線のmoveTo/lineToの値
    private var _onLogging:Boolean = false; // ログ取得中かどうか
    
    private var _drawApplication:Application;
    private var _canvasWindow:GPCanvasWindowControl;
    private var _penWindow:PenDetailWindowControl;
    private var _layerWindow:GPLayerWindowControl;

    public function eventMoveTo(x:Number, y:Number):void {
      var ix:int = Math.floor(x);
      var iy:int = Math.floor(y);
      var dx:int = ix - _preX;
      var dy:int = iy - _preY;
      if (_onLogging) {
        if (dx >= -64 && dx <= 63 && dy >= -64 && dy <= 63) {
          // dxもdyも7bitに収まる場合
          writeShort(0x4000 | (dx << 7) & 0x3f80 | dy & 0x7f);
        } else {
          writeByte(ACTION_MOVETO);
          writeShort(dx);
          writeShort(dy);
        }
        _preX = ix;
        _preY = iy;
        _logCount++;
      }
      _pen.moveTo(ix, iy);
      trace('MOVE_TO x:' + ix + ' y:' + iy);
      
      invokeInsertDrawLayer();
      _drawedLine = false;
    }
    
    public function eventLineTo(x:Number, y:Number):void {
      var ix:int = Math.floor(x);
      var iy:int = Math.floor(y);
      if (!_pen.lineTo(ix, iy)) { // 同じ座標だったらイベントキャンセル
        return;
      }
      if (_onLogging) {
        var dx:int = ix - _preX;
        var dy:int = iy - _preY;
        if (dx >= -64 && dx <= 63 && dy >= -64 && dy <= 63) {
          // dxもdyも7bitに収まる場合
          writeShort(0xc000 | (dx << 7) & 0x3f80 | dy & 0x7f);
        } else {
          writeByte(ACTION_LINETO);
          writeShort(dx);
          writeShort(dy);
        }
        _preX = ix;
        _preY = iy;
        _logCount++;
      }
      trace('LINE_TO x:' + ix + ' y:' + iy);
      _drawedLine = true;
    }
    
    private function invokePenChange():void {
      if (_penWindow) {
        _penWindow.changePen(_pen.mode, _pen.color, _pen.alpha, _pen.thickness);
      }
    }
    
    private function invokePenCancelTool():void {
      if (_penWindow) {
        _penWindow.cancelTool();
      }
    }

    // 一時的にUIのみのペン状態を変える
    private function invokePenTempChange(mode:uint, color:uint, alpha:Number, thickness:uint):void {
      if (_penWindow) {
        _penWindow.changePen(mode, color, alpha, thickness);
      }      
    }
    
    public function eventLineStyleThickness(thickness:uint):void {
      if (_pen.thickness == thickness) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_THICKNESS);
        writeByte(thickness);
        _logCount++;
      }
      _pen.thickness = thickness;
      trace('LINE_STYLE thickness:' + thickness);

      invokePenChange();
    }
    
    public function eventLineStyleColor(rgbcolor:uint):void {
      if (_pen.color == rgbcolor) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_COLOR);
        writeUInt(rgbcolor);
        _logCount++;
      }
      _pen.color = rgbcolor;
      trace('LINE_STYLE color:' + rgbcolor);

      invokePenChange();
    }
    
    public function eventLineStyleAlpha(alpha:Number):void {
      if (_pen.alpha == alpha) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_ALPHA);
        writeDouble(alpha);
        _logCount++;
      }
      _pen.alpha = alpha;
      trace('LINE_STYLE alpha:' + alpha);

      invokePenChange();
    }
    
    public function eventLineStyleMiterLimit(miterLimit:Number):void {
      if (_pen.miterLimit == miterLimit) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_MITER_LIMIT);
        writeDouble(miterLimit);
        _logCount++;
      }
      _pen.miterLimit = miterLimit;
      trace('LINE_STYLE miterLimit:' + miterLimit);

      invokePenChange();
    }
    
    public function eventLineStyleBlendMode(blendMode:String):void {
      if (_pen.blendMode == blendMode) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_BLEND_MODE);
        writeUTF(blendMode);
        _logCount++;
      }
      _pen.blendMode = blendMode;
      trace('LINE_STYLE blendMode:' + blendMode);

      invokePenChange();
    }
    
    public function eventLineStyleScaleMode(scaleMode:String):void {
      if (_pen.scaleMode == scaleMode) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_SCALE_MODE);
        writeUTF(scaleMode);
        _logCount++;
      }
      _pen.scaleMode = scaleMode;
      trace('LINE_STYLE scaleMode:' + scaleMode);

      invokePenChange();
    }
    
    public function eventLineStyleCapsStyle(capsStyle:String):void {
      if (_pen.capsStyle == capsStyle) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_CAPS);
        writeUTF(capsStyle);
        _logCount++;
      }
      _pen.capsStyle = capsStyle;
      trace('LINE_STYLE capsStyle:' + capsStyle);

      invokePenChange();
    }
    
    public function eventLineStyleJointStyle(jointStyle:String):void {
      if (_pen.jointStyle == jointStyle) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_JOINTS);
        writeUTF(jointStyle);
        _logCount++;
      }
      _pen.jointStyle = jointStyle;
      trace('LINE_STYLE jointStyle:' + jointStyle);

      invokePenChange();
    }
    
    public function eventLineStylePixelHinting(pixelHinting:Boolean):void {
      if (_pen.pixelHinting == pixelHinting) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LINESTYLE);
        writeByte(LINESTYLE_PIXEL_HINTING);
        writeBoolean(pixelHinting);
        _logCount++;
      }
      _pen.pixelHinting = pixelHinting;
      trace('LINE_STYLE pixelHinting:' + pixelHinting);

      invokePenChange();
    }
    
    public function eventDrawShapeOnBitmap():void {
      if (_onLogging) {
        writeByte(ACTION_DRAW_SHAPE_ON_BITMAP);
        _logCount++;
      }
      this.drawShapeOnBitmap();
      trace('DRAW_SHAPE_ON_BITMAP');
    }
    
    public function eventUndo():void {
      var obj:Object = _undoBuffer.undo();
      if (!obj) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_UNDO);
        _logCount++;
      }
      _layerArray.dataForUndo = obj;
      _changeUndoRedoHandler(_undoBuffer.undoCount, _undoBuffer.redoCount);
      invokeLayerChange();
      trace('UNDO');
    }
    
    public function eventRedo():void {
      var obj:Object = _undoBuffer.redo();
      if (!obj) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_REDO);
        _logCount++;
      }
      _layerArray.dataForUndo = obj;
      _changeUndoRedoHandler(_undoBuffer.undoCount, _undoBuffer.redoCount);
      invokeLayerChange();
      trace('REDO');
    }
    
    public function eventBeginFill(color:uint, alpha:Number):void {
      if (_onLogging) {
        writeByte(ACTION_BEGIN_FILL);
        writeUInt(color);
        writeDouble(alpha);
        _logCount++;
      }
      _pen.beginFill(color, alpha);
      trace('BEGIN_FILL color:'+ color + ' alpha:' + alpha);
    }
    
    public function eventEndFill():void {
      if (_onLogging) {
        writeByte(ACTION_END_FILL);
        _logCount++;
      }
      _pen.endFill();
      trace('END_FILL');
    }
    
    public function eventDrawCircle(radius:Number):void {
      if (_onLogging) {
        // 直前のmoveToの座標を中心。よって、半径のみ保存
        writeByte(ACTION_DRAW_CIRCLE);
        writeDouble(radius);
        _logCount++;
      }
      _pen.drawCircle(radius);
      trace('DRAW_CIRCLE radius:' + radius);
    }
    
    public function eventFloodFill():void {
      if (_onLogging) {
        writeByte(ACTION_FLOOD_FILL);
        _logCount++;
      }
      _pen.floodFill();
      pushUndoBuffer();
      invokeRemoveDrawLayer();
      trace('FLOOD_FILL');
    }
    
    public function eventSetPixel(x:Number, y:Number):void {
      var ix:int = Math.floor(x);
      var iy:int = Math.floor(y);
      if (!_pen.setPixel(ix, iy)) { // 同じドットだったらイベントキャンセル
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_SET_PIXEL);
        writeShort(ix);
        writeShort(iy);
        _logCount++;
      }
      pushUndoBuffer();
      trace('SET_PIXEL');
    }

    private function invokeLayerChange():void {
      if (_layerWindow) {
        _layerWindow.changeLayer();
        _logCount++;
      }
      // _pen.setLineStyle();
    }
    
    public function eventLayerNew():void {
      if (!_layerArray.insertNew()) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_NEW);
        _logCount++;
      }
      trace('LAYER_NEW');

      pushUndoBuffer();
      invokeLayerChange();
    }
    
    public function eventLayerCopy():void {
      if (!_layerArray.copy()) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_COPY);
        _logCount++;
      }
      trace('LAYER_COPY');
      
      pushUndoBuffer();
      invokeLayerChange();
    }
    
    public function eventLayerSwap(fromIndex:uint, toIndex:uint):void {
      if (!_layerArray.swap(fromIndex, toIndex)) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_SWAP);
        writeByte(fromIndex);
        writeByte(toIndex);
        _logCount++;
      }
      trace('LAYER_SWAP from:' + fromIndex + ' to:' + toIndex);
      
      pushUndoBuffer();
      invokeLayerChange();
    }
    
    public function eventLayerMergeWithBelow():void {
      if (!_layerArray.mergeWithBelow()) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_MERGE_WITH_BELOW);
        _logCount++;
      }
      trace('LAYER_MERGE_WITH_BELOW');

      pushUndoBuffer();
      invokeLayerChange();
    }
    
    public function eventLayerRemove():void {
      if (!_layerArray.remove()) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_REMOVE);
        _logCount++;
      }
      trace('LAYER_REMOVE');

      pushUndoBuffer();
      invokeLayerChange();
    }
    
    public function eventLayerChangeTarget(target:uint):void {
      if (_layerArray.targetIndex == target) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_CHANGE_TARGET);
        writeByte(target);
        _logCount++;
      }
      _layerArray.targetIndex = target;
      trace('LAYER_CHANGE_TARGET target:' + target);

      // UndoRedoには反映しない
      invokeLayerChange();
    }
    
    public function eventLayerChangeVisible(target:uint, visible:Boolean):void {
      if (!_layerArray.changeVisible(target, visible)) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_CHANGE_VISIBLE);
        writeByte(target);
        writeBoolean(visible);
        _logCount++;
      }
      trace('LAYER_CHANGE_VISIBLE target:' + target + ' value:' + visible);

      // UndoRedoには反映しない from 0.9, 0.? ～ 0.8では反映していた。
      invokeLayerChange();
    }
    
    public function eventLayerChangeBlendMode(blendMode:String):void {
      if (_layerArray.targetLayerBlendMode == blendMode) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_CHANGE_BLEND_MODE);
        writeUTF(blendMode);
        _logCount++;
      }
      _layerArray.targetLayerBlendMode = blendMode;
      trace('LAYER_CHANGE_BLEND_MODE blendMode:' + blendMode);

      pushUndoBuffer();
      invokeLayerChange();
    }
    
    public function eventLayerChangeAlpha(alpha:Number):void {
      if (_layerArray.targetLayerAlpha == alpha) {
        return;
      }
      if (_onLogging) {
        writeByte(ACTION_LAYER_CHANGE_ALPHA);
        writeDouble(alpha);
        _logCount++;
      }
      _layerArray.targetLayerAlpha = alpha;
      trace('LAYER_CHANGE_ALPHA alpha:' + alpha);

      pushUndoBuffer();
      invokeLayerChange();
    }
    
    // いまはログとってないイベントたち。

    public function eventLayerChangeLock(target:uint, lock:Boolean):void {
      if (!_layerArray.changeLock(target, lock)) {
        return;
      }
      if (_onLogging) {
        //
      }
      // trace('LAYER_CHANGE_LOCK target:' + target + ' value:' + lock);
    }
    
    public function eventCanvasMove(x:Number, y:Number):void {
      if (_onLogging) {
        // logging
      }
      _canvas.move(x, y);
      //trace('eventCanvasMove x:' + alpha);
    }
    
    public function eventCanvasScale(scale:Number):void {
      if (_onLogging) {
        // logging
      }
      _canvas.scaleX = scale;
      _canvas.scaleY = scale;
      //trace('eventCanvasMove scale:' + alpha);
    }

    public function eventSetAdditionalNumber(num:uint):void {
      if (_onLogging) {
        // logging
      }
      _canvas.setAdditionalNumber(num);
    }
    
    public function eventSetAdditionalBox(visible:Boolean):void {
      if (_onLogging) {
        // logging
      }
      _canvas.setAdditionalBox(visible);
    }

    public function eventSetAdditionalSkew(visible:Boolean):void {
      if (_onLogging) {
        // logging
      }
      _canvas.setAdditionalSkew(visible);
    }
    
    public function eventSetPenMode(mode:uint):void {
      if (_onLogging) {
        // logging
      }
      _pen.mode = mode;

      invokePenChange();

      if (_canvas) {
        switch (mode) {
        case GPPen.PEN_MODE_DROPPER:
          _canvas.setCursor(dropperIcon);
          break;
        case GPPen.PEN_MODE_HANDTOOL:
          _canvas.setCursor(handOpenIcon);
          break;
        case GPPen.PEN_MODE_ERASER:
           // FIXME: give me eraser icon
          _canvas.setCursor(null);
          break;
        case GPPen.PEN_MODE_PIXEL:
          break;
        default:
          _canvas.setCursor(null);
        }
        if (mode == GPPen.PEN_MODE_DROPPER) {
        } else {
        }        
      }
    }

    public function get dataForPost():Object {
      var o:Object = _layerArray.dataForPost;
      o['compressed_log'] = compressedLog;
      o['info']['log_count'] = _logCount;
      o['info']['undo_buffer_size'] = _undoBufferSize;
      if (_penWindow) {
        o['info']['pen_details'] = _penWindow.dataForPost;
      }
      return o;
    }
    
    public function get compressedLog():ByteArray {
      var cl:ByteArray = new ByteArray();
      var tempPos:uint = _log.position;
      _log.compress();
      cl.writeBytes(_log);
      _log.uncompress();
      _log.position = tempPos;
      return cl;
    }
    
    public function get canvasWidth():uint {
      return _canvasWidth;
    }

    public function get canvasHeight():uint {
      return _canvasHeight;
    }
    
    public function get undoBufferSize():uint {
      return _undoBufferSize;
    }
    
    /*** マウスイベントを、Loggerのイベントに変換する ***/
    
    private var _drawing:Boolean = false; // 描画中かどうか
    private var _handtoolScrollBase:Point; // ハンドツールのつかみ元
    private var _fromPoint:Point; // 直線ツールの開始点
    private var _drawedLine:Boolean; // マウスクリックでドットを描くための、moveToしたあとに直線描画したかどうかのフラグ

        // マウス座標から描画座標に変換。
        private static function zz(n:Number):Number {
          return Math.floor(n) + 0.5;
        }
        // マウス座標の描画座標での比較
        public static function comparePoint(ax:Number, ay:Number, bx:Number, by:Number):Boolean {
          return (zz(ax) == zz(bx) && zz(ay) == zz(by));
        }
    
    public function mouseDown(evt:MouseEvent):void {
      switch (_pen.mode) {
      case GPPen.PEN_MODE_HAND:
      case GPPen.PEN_MODE_ERASER:
        // moveToして、ペンの状態を設定し、ペンの状態変化をログし、始点の座標を覚えさせる
        // FIXME: lintToまでmoveToを遅延させよう！
        if (!_layerArray.isTargetLayerVisible) {
          Alert.show('不可視の状態では描画できません！', '手書き/消しゴムツール');
          return;
        }
        if (_layerArray.isTargetLayerLocked) {
          Alert.show('ロックされています！', '手書き/消しゴムツール');
          return;
        }
        _drawing = true;
        this.eventMoveTo(evt.localX, evt.localY);
        break;
      case GPPen.PEN_MODE_LINE:
      case GPPen.PEN_MODE_RECT:
      case GPPen.PEN_MODE_ELLIPSE:
      case GPPen.PEN_MODE_ROUND_RECT:
        if (!_layerArray.isTargetLayerVisible) {
          Alert.show('不可視の状態では描画できません！', '描画ツール');
          return;
        }
        if (_layerArray.isTargetLayerLocked) {
          Alert.show('ロックされています！', '描画ツール');
          return;
        }
        _fromPoint = new Point(evt.localX, evt.localY);
        _drawing = true;
        
        // 描画用
        invokeInsertDrawLayer();
        break;
      case GPPen.PEN_MODE_HANDTOOL:
        if (_canvasWindow) {
          _fromPoint = new Point(evt.localX, evt.localY);
          _handtoolScrollBase = _canvasWindow.canvasScrollPosition;
        }
        break;
      case GPPen.PEN_MODE_DROPPER:
        invokePenTempChange(_pen.mode, _layerArray.getColor(evt.localX, evt.localY), _pen.alpha, _pen.thickness);
        break;
      case GPPen.PEN_MODE_FLOOD_FILL:
        if (!_layerArray.isTargetLayerVisible) {
          Alert.show('不可視の状態では描画できません！', 'バケツツール');
          return;
        }
        if (_layerArray.isTargetLayerLocked) {
          Alert.show('ロックされています！', 'バケツツール');
          return;
        }
        this.eventMoveTo(evt.localX, evt.localY);
        this.eventFloodFill();
        break;
      case GPPen.PEN_MODE_PIXEL:
        if (!_layerArray.isTargetLayerVisible) {
          Alert.show('不可視の状態では描画できません！', 'ドット絵ツール');
          return;
        }
        if (_layerArray.isTargetLayerLocked) {
          Alert.show('ロックされています！', 'ドット絵ツール');
          return;
        }
        this.eventSetPixel(evt.localX, evt.localY);
        _drawing = true;
        break;
      }
    }

    public function mouseMove(evt:MouseEvent):void {
      if (_canvasWindow) {
        var st:String = '座標(' + uint(evt.localX) + ', ' + uint(evt.localY) + ')';
        var col:uint = _layerArray.getColor32(evt.localX, evt.localY);
        st += ' 不透明度:' + (new Number((col >> 24) & 0xFF) / 255).toPrecision(2);
        st += ' 色:(' + ((col >> 16) & 0xFF) + ',' + ((col >> 8) & 0xFF) + ',' + (col & 0xFF) + ')';
        _canvasWindow.statusText = st;
      }
      
      if (evt.buttonDown) {
        switch (_pen.mode) {
        case GPPen.PEN_MODE_HAND:
        case GPPen.PEN_MODE_ERASER:
          if (_drawing) {
            this.eventLineTo(evt.localX, evt.localY);
          }
          break;
        case GPPen.PEN_MODE_DROPPER:
          invokePenTempChange(_pen.mode, _layerArray.getColor(evt.localX, evt.localY), _pen.alpha, _pen.thickness);
          break;
        case GPPen.PEN_MODE_HANDTOOL:
          if (_canvasWindow && _handtoolScrollBase) {
            _canvasWindow.scrollCanvas(_handtoolScrollBase.x + (_fromPoint.x - evt.localX),
                                       _handtoolScrollBase.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 GPPen.PEN_MODE_LINE:
          if (_drawing) {
            _pen.previewLineTo(_fromPoint.x, _fromPoint.y, evt.localX, evt.localY);
          }
          break;
        case GPPen.PEN_MODE_PIXEL:
          if (_drawing) {
            this.eventSetPixel(evt.localX, evt.localY);
          }
          break;
        }
      }
    }
    public function mouseUp(evt:MouseEvent):void {
      switch (_pen.mode) {
      case GPPen.PEN_MODE_HAND:
      case GPPen.PEN_MODE_ERASER:
        if (_drawing) {
          if (!_drawedLine) {
            // 線の透明度は０0にして、塗りの透明度に線の透明度を適用する。
            var tmpAlpha:Number = _pen.alpha;
            this.eventLineStyleAlpha(0);
            this.eventBeginFill(_pen.color, tmpAlpha);
            this.eventDrawCircle(_pen.thickness / 2);
            this.eventEndFill();
            this.eventLineStyleAlpha(tmpAlpha);
          }
          this.eventDrawShapeOnBitmap();
          _drawing = false;
        }
        break;
      case GPPen.PEN_MODE_LINE:
        if (_drawing) {
          invokeRemoveDrawLayer();
          if (!comparePoint(_fromPoint.x, _fromPoint.y, evt.localX, evt.localY)) {
            // 始点と終点が違う場合にのみ線を引く
            this.eventMoveTo(_fromPoint.x, _fromPoint.y);
            this.eventLineTo(evt.localX, evt.localY);
            this.eventDrawShapeOnBitmap();          
          }
          _drawing = false;
        }
        break;
      case GPPen.PEN_MODE_DROPPER:
        this.eventLineStyleColor(_layerArray.getColor(evt.localX, evt.localY));
        invokePenChange();
        invokePenCancelTool();
        break;
      case GPPen.PEN_MODE_HANDTOOL:
        _handtoolScrollBase = null;
        break;
      case GPPen.PEN_MODE_PIXEL:
        _drawing = false;
        break;
      }
    }
    
    // stage全体でmouseUpがあった場合。
    // mouseUpと二重で呼ばれる場合があるので注意
    public function extMouseUp(evt:MouseEvent):void {
    }
    
    public function mouseOut(evt:MouseEvent):void {
      switch (_pen.mode) {
      case GPPen.PEN_MODE_HAND:
      case GPPen.PEN_MODE_ERASER:
      case GPPen.PEN_MODE_PIXEL:
        if (_drawing) {
          mouseUp(evt);
        }
        break;
      case GPPen.PEN_MODE_DROPPER:
        invokePenChange();
        invokePenCancelTool();
        break;
      case GPPen.PEN_MODE_LINE:
        if (_drawing) {
          _drawing = false;
          invokeRemoveDrawLayer();
        }
        break;
      }
    }
    // イベントハンドラおわり
    public function get canvas():GPCanvas {
      return _canvas;
    }
    public function get logCount():uint {
      return _logCount;
    }
    public function get layerArray():GPLayerArray {
      return _layerArray;
    }
    public function get baseInfo():Object {
      return _baseInfo;
    }
  }
}