root/as3/gunyarapaint/trunk/gunyarapaint/src/gunyarapaint.as

private const DEBUG:Boolean = true;

import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;

import gunyarapaint.Com;
import gunyarapaint.controls.GPCanvas;
import gunyarapaint.entities.GPPen;
import gunyarapaint.entities.GPLogger;
import gunyarapaint.utils.MiscUtils;

import mx.controls.Alert;
import mx.events.FlexEvent;
import mx.events.NumericStepperEvent;
import mx.events.SliderEvent;
import mx.managers.PopUpManager;

private var gpCanvas:GPCanvas;
private var basex:uint, basey:uint, baseWidth:uint, baseHeight:uint;

private var comm:Com;
private var oekakiId:uint;
private var redirectUrl:String;
private var onPost:Boolean = false;

private var canvasWidth:uint;
private var canvasHeight:uint;
private var undoBufferSize:uint;

private const ALERT_TITLE:String = 'お絵カキコ';
private const MAX_CANVAS_WIDTH:uint = 500;
private const MAX_CANVAS_HEIGHT:uint = 500;
private const MIN_CANVAS_WIDTH:uint = 16;
private const MIN_CANVAS_HEIGHT:uint = 16;

public function init():void {  

  if (DEBUG) {
    versionLabel.text += 'debug';
  }

  this.enabled = false;
  comm = new Com();
  comm.addEventListener('completeGetData', commCompleteHandler);
  
  if (parameters['postUrl'] && parameters['cookie'] && parameters['magic'] && parameters['redirectUrl']) {
    comm.setPostEnv(parameters['postUrl'], parameters['cookie'], parameters['magic']);
    postOekakiButton.enabled = true;
    redirectUrl = parameters['redirectUrl'];
  }
  if (parameters['undoBufferSize']) {
    undoBufferSize = int(parameters['undoBufferSize']);
    if (undoBufferSize < 0) {
      Alert.show('最大アンドゥ回数が少なすぎます。', ALERT_TITLE);      
    }
    if (undoBufferSize > 32) {
      Alert.show('最大アンドゥ回数が多すぎます。', ALERT_TITLE);      
    }
  } else {
    if (DEBUG) {
      undoBufferSize = 16;
    } else {
      return;
    }
  }
  if (parameters['oekakiId'] && parameters['baseImgUrl']) {
    oekakiId = uint(parameters['oekakiId']);
    var url:String = parameters['baseImgUrl'];
    comm.loadUrl(url);
    this.enabled = false;
  } else {
    if (parameters['canvasWidth'] && parameters['canvasHeight']) {
      canvasWidth = int(parameters['canvasWidth']);
      canvasHeight = int(parameters['canvasHeight']);
      if (canvasWidth < MIN_CANVAS_WIDTH || canvasHeight < MIN_CANVAS_HEIGHT) {
        Alert.show('キャンバスサイズが小さすぎます。', ALERT_TITLE);
        return;
      }
      if (canvasWidth > MAX_CANVAS_WIDTH || canvasHeight > MAX_CANVAS_HEIGHT) {
        Alert.show('キャンバスサイズが大きすぎます。', ALERT_TITLE);
        return;
      }
    } else {
      if (DEBUG) {
        canvasWidth = 300; canvasHeight = 400;
      } else {
        return;
      }
    }
    gpCanvas = gpCanvasWindow.createCanvas(canvasWidth, canvasHeight, undoBufferSize, null, null, penDetailWindow.pen);
    initGunyaraPaintCanvas();
  }

  // canvasのpopup
  PopUpManager.addPopUp(gpCanvasWindow, this);
  
  if (DEBUG) {
    logPlayButton.addEventListener(FlexEvent.BUTTON_DOWN, playLogHandler);
    checkPngButton.addEventListener(FlexEvent.BUTTON_DOWN, checkPngHandler);
    logPlayButton.visible = true;
    checkPngButton.visible = true;
  }
  
  // ペン詳細
  PopUpManager.addPopUp(penDetailWindow, this);
  // FIXME: 最終的にはWindowのほうがイベント投げる
  penDetailWindow.penDetail.addEventListener('changePen', changePenHandler);

  // レイヤー
  PopUpManager.addPopUp(gpLayerWindow, this);
  
  // キャンバス回転スライダ
  canvasZoom.addEventListener(SliderEvent.CHANGE, canvasZoomHandler);
  canvasZoom.addEventListener(SliderEvent.THUMB_DRAG, canvasZoomHandler);
  canvasRotate.addEventListener(SliderEvent.CHANGE, canvasRotateHandler);
  canvasRotate.addEventListener(SliderEvent.THUMB_DRAG, canvasRotateHandler);
  zoomResetButton.addEventListener(FlexEvent.BUTTON_DOWN, zoomResetButtonHandler);
  rotateResetButton.addEventListener(FlexEvent.BUTTON_DOWN, rotateResetButtonHandler);
  
  // アンドゥ・リドゥ
  undoButton.addEventListener(FlexEvent.BUTTON_DOWN, undoButtonHandler);
  redoButton.addEventListener(FlexEvent.BUTTON_DOWN, redoButtonHandler);
   
  // 補助線
  additionalNumberStepper.addEventListener(NumericStepperEvent.CHANGE, additionalNumberStepperHandler);
  additionalBoxCheckBox.addEventListener(Event.CHANGE, additionalBoxCheckBoxHandler);
  additionalSkewCheckBox.addEventListener(Event.CHANGE, additionalSkewCheckBoxHandler);
  
  // 投稿
  postOekakiButton.addEventListener(FlexEvent.BUTTON_DOWN, postOekakiButtonHandler);

  this.enabled = true;
}

private function appComplete():void {
  stage.addEventListener(KeyboardEvent.KEY_DOWN, shortCutKeyDownHandler);  
  stage.addEventListener(KeyboardEvent.KEY_UP, shortCutKeyUpHandler);  
  stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
  stage.addEventListener(MouseEvent.MOUSE_OUT, mouseUpHandler); // これを入れるとマズい。
}

// canvasでの外のmouseUpをcanvasに通知  
private function mouseUpHandler(evt:MouseEvent):void {
  gpCanvas.extMouseUp();
}

private function initGunyaraPaintCanvas():void {
  // undo/redoの状態変化
  gpCanvas.addEventListener('changeUndoRedo', changeUndoRedoHandler);
  gpCanvas.rotation = 0;
  gpLayerWindow.canvas = gpCanvas;

  toolCanvas.x = (this.width - toolCanvas.width) / 2;
}

private function commCompleteHandler(evt:Event):void {
  if (onPost) {
    onPost = false;
    if (comm.getErrorStr()) {
      // error
      Alert.show(comm.getErrorStr(), ALERT_TITLE);
      this.enabled = true;
    } else if (comm.getStringData() != '') {
      Alert.show(comm.getStringData(), ALERT_TITLE);
      this.enabled = true;
    } else {
      // redirect
      Com.redirect(redirectUrl);
    }
  } else {
    // 続きを書く
    var baseImg:BitmapData = Bitmap(comm.getContent()).bitmapData;
    canvasWidth = baseImg.width;
    canvasHeight = baseImg.height;
    gpCanvas = gpCanvasWindow.createCanvas(0, 0, undoBufferSize, null, baseImg, penDetailWindow.pen);
    initGunyaraPaintCanvas();
    this.enabled = true;
  }
}

private function canvasZoomHandler(evt:SliderEvent):void {
  gpCanvasWindow.zoomCanvas(evt.value);
}

private function canvasRotateHandler(evt:SliderEvent):void {
  gpCanvasWindow.rotateCanvas(evt.value);
}
/*
private function changeGunyaraPaintRect():void {
  // 外部のスクリプト呼び出し。主に回転時のサイズ変更
  if (this.width < (toolCanvas.width + 4)) {
    this.width = toolCanvas.width + 4;
  }
  if (this.height < 312) { // for color picker
    this.height = 312;
  }
  if (ExternalInterface.available) {
    try {
      ExternalInterface.call("changeGunyaraPaintRect", this.width, this.height);
    } catch (e:SecurityError) {
    } catch (e:Error) {
    }
  }  
}
*/

private function undoButtonHandler(evt:FlexEvent):void {
  gpCanvas.undo();
}
private function redoButtonHandler(evt:FlexEvent):void {
  gpCanvas.redo();
}
private function additionalNumberStepperHandler(evt:NumericStepperEvent):void {
  gpCanvas.setAdditionalNumber(evt.value);
}
private function additionalBoxCheckBoxHandler(evt:Event):void {
  gpCanvas.setAdditionalBox(evt.target.selected);
}
private function additionalSkewCheckBoxHandler(evt:Event):void {
  gpCanvas.setAdditionalSkew(evt.target.selected);
}
private function changeUndoRedoHandler(evt:Event):void {
  var undoCount:Number = gpCanvas.getUndoCount();
  var redoCount:Number = gpCanvas.getRedoCount();
  if (undoCount > 0) {
    undoButton.label = 'アンドゥ (' + undoCount + ')';
    undoButton.enabled = true;
  } else {
    undoButton.label = 'アンドゥ';
    undoButton.enabled = false;
  }
  if (redoCount > 0) {
    redoButton.label = 'リドゥ (' + redoCount + ')';
    redoButton.enabled = true;
  } else {
    redoButton.label = 'リドゥ';
    redoButton.enabled = false;
  }
}

private function postOekakiButtonHandler(evt:Event):void {
  if (messageTextArea.text == '') {
    Alert.show('書き込みが空です。絵のタイトルなどの情報を書き込んでください。', ALERT_TITLE);
    return;
  }
  if (gpCanvas.logger.getLogCount() == 0) {
    Alert.show('絵が描かれていません。お絵かきしてください。', ALERT_TITLE);
    return;
  }
  this.enabled = false;
  onPost = true;
  comm.postOekaki(fromTextInput.text,
                  messageTextArea.text,
                  gpCanvas.getPNGImage(),
                  gpCanvas.compressedLog,
                  oekakiId);
}

private function changePenHandler(evt:Event):void {
  gpCanvasWindow.pen = penDetailWindow.pen; 
}

private var logger:GPLogger;
private var logcan:GPCanvas;

private function playLogHandler(evt:FlexEvent):void {
  logger = gpCanvas.logger;
  logcan = logger.createViewerCanvas(null);
  this.addChild(logcan);
  logger.play(logcan, 1000);
}

private function checkPngHandler(evt:FlexEvent):void {
  if (MiscUtils.compareObject(
        logcan.getPNGImage(), gpCanvas.getPNGImage())) {
    Alert.show('合ってる。');
  } else {
    Alert.show('違うよ！');
  }
}

private function rotateResetButtonHandler(evt:Event):void {
  setRotate(0);
}

private function zoomResetButtonHandler(evt:Event):void {
  setZoom(1);
}

private function setRotate(v:Number):void {
  canvasRotate.value = v;
  gpCanvasWindow.rotateCanvas(canvasRotate.value);
}

private function setZoom(v:Number):void {
  canvasZoom.value = v;
  gpCanvasWindow.zoomCanvas(canvasZoom.value);  
}

private function shortCutKeyDownHandler(evt:KeyboardEvent):void {
  if (evt.target == this.fromTextInput ||
      evt.target == this.messageTextArea) {
    return;
  }
  switch (evt.keyCode) {
  case Keyboard.CONTROL:
    penDetailWindow.penDetail.setTool(GPPen.PEN_MODE_DROPPER, true);
    break;
  case Keyboard.SHIFT:
    break;
  case Keyboard.SPACE:
    penDetailWindow.penDetail.setTool(GPPen.PEN_MODE_HANDTOOL, true);
    break;
  case 48: // 0
  case 96: // ten-key 0
    if (evt.ctrlKey) {
      if (evt.shiftKey) {
        setRotate(0);
      } else {
        setZoom(1);
      }
    }
    break;
  case 89: // y
    gpCanvas.redo();
    break;
  case 90: // z
    gpCanvas.undo();
    break;
  case 107: // ten key +
    if (evt.ctrlKey) {
      // ctrl-+
      setZoom(canvasZoom.value + 1);
    }
    break;
  case 109: // ten key -
    if (evt.ctrlKey) {
      // ctrl-'-'
      setZoom(canvasZoom.value - 1);
    }
    break;
  case 187:
    if (evt.shiftKey && evt.ctrlKey) {
      // ctrl-+
      setZoom(canvasZoom.value + 1);
    }
    break;
  case 189:
    if (evt.ctrlKey) {
      // ctrl--
      setZoom(canvasZoom.value - 1);
    }
    break;
  default:
    Alert('' + evt.keyCode);
    break;
  }
}

private function shortCutKeyUpHandler(evt:KeyboardEvent):void {
  if (evt.target == this.fromTextInput ||
      evt.target == this.messageTextArea) {
    return;
  }
  switch (evt.keyCode) {
  case Keyboard.CONTROL:
    penDetailWindow.penDetail.setTool(GPPen.PEN_MODE_DROPPER, false);
    break;
  case Keyboard.SPACE:
    penDetailWindow.penDetail.setTool(GPPen.PEN_MODE_HANDTOOL, false);
    break;
  return;
  }
}