Keter.technology このページをアンテナに追加 RSSフィード

2010.04.08

AS3で getURLの代替関数を使用する

getURL

I ♥ getURL

ActionScript3.0から僕の好きな getURL関数が使用できなくなってしまいましたので、簡素な代替関数を作成しました。

下記のボタンより getURL.asファイルをダウンロード後、任意のクラスパスへ保存してご使用ください。

Download

【使用方法】

http://exsample.com/ を開く

getURL("http://exsample.com/");

http://exsample.com/ を新しいウィンドウで開く

getURL("http://exsample.com/", "_blank");

【パラメータについて】

url

呼び出し先の URL
[String][省略不可]

target

URLを開くターゲットウィンドウ
[String][省略可][初期値:"_self"]

ソースコード

package {
  import flash.net.navigateToURL;
  import flash.net.URLRequest;
  public function getURL(url:String, target:String="_self"):void {
    if (url == null) {
      return;
    }
    try {
      navigateToURL(new URLRequest(url),target);
    } catch (error:Error) {
      return;
    }
  }
}

Download

【補足】

トラッキングの取得やポップアップウィンドウの展開など、JavaScriptを呼び出すには従来の getURL関数ではなく、ExternalInterfaceクラスを使用するようです。

JavaScriptの関数を呼び出す

//ExternalInterfaceクラスのインポート
import flash.external.ExternalInterface;

//呼び出す JavaScriptの関数名
var callJavaScriptFunction:String = "JSFunctionName";
//JavaScriptの関数に渡す第一引数
var callJavaScriptArguments:String = "JSFunctionArgs";
//ExternalInterfaceクラスの戻り値をストリングとして格納
var callJavaScriptValue:String = 
    ExternalInterface.call(
        callJavaScriptFunction,
        callJavaScriptArguments
    ).toString(); //ここでストリングに変換した方が安全のようです

2010.04.02

AS3で外部ファイルの読み込みとロード状況の監視をする「SWFLoader」クラス - 改訂版 -

SWFLoader

SWFLoader

ActionScript3.0で外部ファイルの読み込みとロード状況の監視をする「SWFLoader」クラスをアップデートしました。以前のエントリーで公開したファイルの改訂版です。

外部ファイルを読み込むターゲットと、外部ファイルへのパスを指定して使用します。ロード開始時と完了時に実行する関数を指定したり、ローディング時とロード完了時のフラグ等を外部から取得することが可能です。

今回の更新では、プログレスバーをスクリプトで描画するよう変更し*1、外部ファイル・プログレスバーのアルファ値(初期値)や、ロード開始するまでの待機時間(秒数)を指定できるようになりました。

また、プログレスバーのサイズ/色/フィルタ設定、パーセントテキストのフォント等を指定できるよう改編しています。

下記のボタンより、サンプルの閲覧およびソースのダウンロードができます。

Sample Download

【使用方法】

main.swfを読み込み

var myLoader:MovieClip = new SWFLoader();
myLoader.load(this, "main.swf");

exsample.jpgを _mcへ読み込み

var _mc:MovieClip = new MovieClip();
addChild(_mc);

var myLoader:MovieClip = new SWFLoader();
myLoader.load(_mc, "exsample.jpg");

main.swfを読み込み、ロード開始時に onLoadFunction関数を実行する

var onLoadFunction:Function = function(){
  trace("外部ファイルのロードが開始されました")
};
var myLoader:MovieClip = new SWFLoader();
myLoader.load(this, "main.swf", onLoadFunction);

main.swfを読み込み、ロード完了時に onCompleteFunction関数を実行する

var onCompleteFunction:Function = function(){
  trace("外部ファイルのロードが完了しました")
};
var myLoader:MovieClip = new SWFLoader();
myLoader.load(this, "main.swf", null, onCompleteFunction);

main.swfとプログレスバーのアルファ(初期値)を 0に指定してロードを開始する

var childDefAlpha:Number = 0;
var loadProgressDefAlpha:Number = 0;

var myLoader:MovieClip = new SWFLoader();
myLoader.load(
  this, 
  "main.swf", 
  onLoadFunction, 
  onCompleteFunction, 
  childDefAlpha, 
  loadProgressDefAlpha
);

2秒後に main.swfの読み込みを開始する

var delaySecond:Number = 2;

var myLoader:MovieClip = new SWFLoader();
myLoader.load(
  this, 
  "main.swf", 
  onLoadFunction, 
  onCompleteFunction, 
  childDefAlpha, 
  loadProgressDefAlpha,
  delaySecond
);

ローディングバーを表示しない

var isLoadProgressBar:Boolean = false;

var myLoader:MovieClip = new SWFLoader();
myLoader.load(
  this, 
  "main.swf", 
  onLoadFunction, 
  onCompleteFunction, 
  childDefAlpha, 
  loadProgressDefAlpha,
  delaySecond,
  isLoadProgressBar
);

ローディングバーにグローフィルタを適用しない

var isLoadProgressBarFilter:Boolean = false;

var myLoader:MovieClip = new SWFLoader();
myLoader.load(
  this, 
  "main.swf", 
  onLoadFunction, 
  onCompleteFunction, 
  childDefAlpha, 
  loadProgressDefAlpha,
  delaySecond,
  isLoadProgressBar,
  isLoadProgressBarFilter
);

ローディングアイコンを表示する

var isLoadProgressIcon:Boolean = true;

var myLoader:MovieClip = new SWFLoader();
myLoader.load(
  this, 
  "main.swf", 
  onLoadFunction, 
  onCompleteFunction, 
  childDefAlpha, 
  loadProgressDefAlpha,
  delaySecond,
  isLoadProgressBar,
  isLoadProgressBarFilter,
  isLoadProgressIcon
);

パーセントテキストを表示する

var isLoadProgressPercent:Boolean = true;

var myLoader:MovieClip = new SWFLoader();
myLoader.load(
  this, 
  "main.swf", 
  onLoadFunction, 
  onCompleteFunction, 
  childDefAlpha, 
  loadProgressDefAlpha,
  delaySecond,
  isLoadProgressBar,
  isLoadProgressBarFilter,
  isLoadProgressIcon,
  isLoadProgressPercent
);

【ロード状況の取得方法】

ローディング中であればメッセージを出力する

if(SWFLoader.loading) trace("まだ読み込み中です…(TT)");

ロードが完了していればメッセージを出力する

if(SWFLoader.complete) trace("読み込みが完了しました\(^o^)/");

外部ファイルの総容量(バイト数)を出力する

trace(SWFLoader.bytesTotal);

外部ファイルの読み込みが完了した容量(バイト数)を出力する

trace(SWFLoader.bytesLoaded);

外部ファイルの読み込みが完了した割合(パーセント)を出力する

trace(SWFLoader.percent);

【プログレスバーのデザイン変更方法】

プログレスバーの色を赤に指定

SWFLoader.barColor = 0xFF0000;

プログレスバーの背景色を緑に指定

SWFLoader.baseColor = 0x00FF00;

プログレスバーの横位置指定

SWFLoader.x = [int];

プログレスバーの縦位置指定

SWFLoader.y = [int];

プログレスバーの横幅指定

SWFLoader.width = [uint];

プログレスバーの縦幅指定

SWFLoader.height = [uint];

プログレスバーの位置とサイズを Rectangleで指定

SWFLoader.rectangle = new Rectangle(x, y, w, h);

グローフィルタの色を青に指定

SWFLoader.filterColor = 0x0000FF;

グローフィルタのアルファ透明度を指定

SWFLoader.filterAlpha = [Number];

グローフィルタの水平方向のぼかし量を指定

SWFLoader.filterBlurX = [Number];

グローフィルタの垂直方向のぼかし量を指定

SWFLoader.filterBlurY = [Number];

グローフィルタのインプリントの強さを指定

SWFLoader.filterStrength = [Number];

グローフィルタのクオリティ(適用する回数)を「高」に指定

SWFLoader.filterQuality = BitmapFilterQuality.HIGH;

グローフィルタの向き(内側/外側)を指定

SWFLoader.filterInner = [Boolean];

グローフィルタを適用するオブジェクトにノックアウト効果を付与するか指定

SWFLoader.filterKnockout = [Boolean];

パーセントテキストのフォント(書体名)を指定

SWFLoader.percentFont = [String];

パーセントテキストのフォントサイズを指定

SWFLoader.percentFontSize = [uint];

パーセントテキストのフォントカラーを黒に指定

SWFLoader.percentFontColor = 0x000000;

【パラメータについて】

$parent

外部ファイルをロードするターゲット
[DisplayObjectContainer][省略不可]

url

ロードする外部ファイルへのパス
[String][省略不可]

onLoadFunction

ロード開始時に実行される関数
[Function][規定値:null][省略可]

onCompleteFunction

ロード完了後に実行される関数
[Function][規定値:null][省略可]

childDefAlpha

外部ファイルのアルファ(初期値)
[Number][規定値:0][省略可]

loadProgressDefAlpha

プログレスバーのアルファ(初期値)
[Number][規定値:0][省略可]

delaySecond

ロード開始するまでの待機時間(秒数)
[Number][規定値:0][省略可]

isLoadProgressBar

プログレスバーの表示
[Boolean][規定値:true][省略可]

isLoadProgressBarFilter

プログレスバーへグローフィルタを適用する
[Boolean][規定値:true][省略可]

isLoadProgressIcon

ローディングアイコンの表示
[Boolean][規定値:false][省略可]

isLoadProgressPercent

パーセントテキストの表示
[Boolean][規定値:false][省略可]

addedLoadClip

別のプログレスバーの指定
[Sprite][規定値:null][省略可]

ソースコード *2

import jp.atziluth.system.SWFLoader;

package jp.atziluth.system{
  import flash.display.DisplayObjectContainer;
  import flash.display.MovieClip;
  import flash.display.Sprite;
  import flash.display.Loader;
  import flash.display.LoaderInfo;
  import flash.geom.Rectangle;
  import flash.filters.BitmapFilterQuality;
  import flash.events.Event;
  import flash.events.IOErrorEvent;
  import flash.events.ProgressEvent;
  import flash.net.URLRequest;
  import flash.utils.Timer;
  import flash.events.TimerEvent;
  import caurina.transitions.Tweener;
  public class SWFLoader extends MovieClip {
    private var $parent:DisplayObjectContainer;
    private var $child:Loader;
    private var $url:URLRequest;
    protected static var onLoadFunction:Function;
    protected static var onCompleteFunction:Function;
    private var childDefAlpha:Number;
    private var loadProgressDefAlpha:Number;
    private static var loadProgress:LoadProgress;
    private static var loadProgressBarColor:uint = 0xFFFFFF;
    private static var loadProgressBaseColor:uint = 0x333333;
    private static var loadProgressX:int = 16;
    private static var loadProgressY:int = 24;
    private static var loadProgressWidth:uint = 135;
    private static var loadProgressHeight:uint = 1;
    private static var loadProgressRectangle:Rectangle;
    private static var loadProgressFilterColor:uint = 0xFFFFFF;
    private static var loadProgressFilterAlpha:Number = 0.8;
    private static var loadProgressFilterBlurX:Number = 2;
    private static var loadProgressFilterBlurY:Number = 2;
    private static var loadProgressFilterStrength:Number = 2;
    private static var loadProgressFilterQuality:Number = BitmapFilterQuality.HIGH;
    private static var loadProgressFilterInner:Boolean = false;
    private static var loadProgressFilterKnockout:Boolean = false;
    private static var loadProgressPercentFont:String = "_serif";
    private static var loadProgressPercentFontSize:uint = 12;
    private static var loadProgressPercentFontColor:uint = 0xFFFFFF;
    private static var addedLoadProgress;
    public static var currentLoadProgress;
    private static var isLoadProgressBar:Boolean;
    private static var isLoadProgressBarFilter:Boolean;
    private static var isLoadProgressIcon:Boolean;
    private static var isLoadProgressPercent:Boolean;
    private static var isLoading:Boolean = false;
    private static var totalBytes:Number;
    private static var loadedBytes:Number;
    private static var per:uint;
    private var loadTimer:Timer;
    private var Tween:Function = Tweener.addTween;
    private var removeTween:Function = Tweener.removeTweens;
    public function load(
        $parent:DisplayObjectContainer, 
        url:String, 
        onLoadFunction:Function=null, 
        onCompleteFunction:Function=null, 
        childDefAlpha:Number=0,
        loadProgressDefAlpha:Number=0,
        delaySecond:Number=0,
        isLoadProgressBar:Boolean=true,
        isLoadProgressBarFilter:Boolean=true,
        isLoadProgressIcon:Boolean=false,
        isLoadProgressPercent:Boolean=false,
        addedLoadClip:Sprite=null
    ):void {
      this.$child = new Loader();
      this.$parent = $parent;
      this.$parent.addChildAt($child, this.$parent.numChildren);
      this.$url = new URLRequest(url);
      SWFLoader.onLoadFunction = onLoadFunction;
      SWFLoader.onCompleteFunction = onCompleteFunction;
      this.childDefAlpha = childDefAlpha;
      this.loadProgressDefAlpha = loadProgressDefAlpha;
      delaySecond ? loadTimer = new Timer(delaySecond * 1000,0):loadTimer = null;
      SWFLoader.loadProgressBar = isLoadProgressBar;
      SWFLoader.loadProgressBarFilter = isLoadProgressBarFilter;
      SWFLoader.loadProgressIcon = isLoadProgressIcon;
      SWFLoader.loadProgressPercent = isLoadProgressPercent;
      if (addedLoadClip) {
        SWFLoader.addedLoadProgress = addedLoadClip;
      } else {
        if (SWFLoader.rectangle == null) {
          SWFLoader.rectangle = new Rectangle(
              SWFLoader.x,
              SWFLoader.y,
              SWFLoader.width,
              SWFLoader.height
          );
        }
        SWFLoader.loadProgress = new LoadProgress(
            SWFLoader.barColor,
            SWFLoader.baseColor,
            SWFLoader.rectangle,
            SWFLoader.filterColor,
            SWFLoader.filterAlpha,
            SWFLoader.filterBlurX,
            SWFLoader.filterBlurY,
            SWFLoader.filterStrength,
            SWFLoader.filterQuality,
            SWFLoader.filterInner,
            SWFLoader.filterKnockout,
            SWFLoader.percentFont,
            SWFLoader.percentFontSize,
            SWFLoader.percentFontColor,
            SWFLoader.loadProgressBar,
            SWFLoader.loadProgressBarFilter,
            SWFLoader.loadProgressIcon,
            SWFLoader.loadProgressPercent
        );
      }
      if (SWFLoader.addedLoadProgress) {
        SWFLoader.currentLoadProgress = SWFLoader.addedLoadProgress;
      } else {
        SWFLoader.currentLoadProgress = SWFLoader.loadProgress;
      }
      $parent.addChildAt(
          SWFLoader.currentLoadProgress,
          $parent.numChildren
      );
      with (SWFLoader.currentLoadProgress) {
        name = "LoadProgress";
        alpha = 0;
        visible = false;
      }
      $child.contentLoaderInfo.addEventListener(Event.OPEN, onLoadHandler);
      $child.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, onProgressHandler);
      $child.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteHandler);
      $child.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, onIOErrorHandler);
      $child.visible = false;
      $child.alpha = this.childDefAlpha;
      loadTimer ? setLoadTimer():execLoad();
    }
    private function setLoadTimer():void {
      loadTimer.addEventListener(TimerEvent.TIMER, execLoadTimer);
      loadTimer.start();
    }
    private function execLoadTimer(event:TimerEvent) {
      loadTimer.removeEventListener(TimerEvent.TIMER, execLoadTimer);
      execLoad();
    }
    private function execLoad():void {
      $child.load($url);
    }
    private function onLoadHandler(event:Event):void {
      with (SWFLoader.currentLoadProgress) {
        alpha = loadProgressDefAlpha;
        visible = true;
      }
      if (SWFLoader.currentLoadProgress.alpha < 1) {
        Tween(SWFLoader.currentLoadProgress,{
          alpha:1,
          time:.25,
          transition:"Strong.easeOut"
        });
      }
      if (SWFLoader.onLoadFunction != null) {
        SWFLoader.onLoadFunction();
      }
      SWFLoader.isLoading = true;
    }
    private function onProgressHandler(event:ProgressEvent):void {
      SWFLoader.bytesTotal = event.bytesTotal;
      SWFLoader.bytesLoaded = event.bytesLoaded;
      SWFLoader.percent = Math.floor(SWFLoader.bytesLoaded / SWFLoader.bytesTotal * 100);
      if (SWFLoader.loadProgressBar) {
        SWFLoader.currentLoadProgress.bar.scaleX = SWFLoader.bytesLoaded / SWFLoader.bytesTotal;
      }
      if (SWFLoader.loadProgressPercent) {
        SWFLoader.currentLoadProgress.percent.getChildByName("percentText").text = String(SWFLoader.percent) + "%";
      }
    }
    private function onCompleteHandler(event:Event):void {
      Tween(SWFLoader.currentLoadProgress,{
        alpha:0,
        time:2,
        transition:"easeInOutCubic",
        onComplete:onFinish
      });
      if (SWFLoader.onCompleteFunction != null) {
        SWFLoader.onCompleteFunction();
      }
      SWFLoader.isLoading = false;
    }
    private function onFinish():void {
      $child.contentLoaderInfo.removeEventListener(Event.OPEN, onLoadHandler);
      $child.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS, onProgressHandler);
      $child.contentLoaderInfo.removeEventListener(Event.COMPLETE, onCompleteHandler);
      $child.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR, onIOErrorHandler);
      $child.visible = true;
      if ($child.alpha < 1) {
        Tween($child, {
          alpha:1,
          time:1,
          transition:"liner",
          onComplete:removeTween,
          onCompleteParams:[$child]
        });
      }
      deleteLoadProgress();
    }
    private function deleteLoadProgress():void {
      while (SWFLoader.currentLoadProgress.numChildren > 0) {
        SWFLoader.currentLoadProgress.removeChildAt(0);
      }
      removeTween(SWFLoader.currentLoadProgress);
    }
    private function onIOErrorHandler(event:IOErrorEvent):void {
      trace(event);
    }
    public static function get loading():Boolean {
      return (SWFLoader.isLoading);
    }
    public static function get complete():Boolean {
      return !(SWFLoader.isLoading);
    }
    public static function set bytesTotal(totalBytes:Number):void {
      SWFLoader.totalBytes = totalBytes;
    }
    public static function get bytesTotal():Number {
      return (SWFLoader.totalBytes);
    }
    public static function set bytesLoaded(loadedBytes:Number):void {
      SWFLoader.loadedBytes = loadedBytes;
    }
    public static function get bytesLoaded():Number {
      return (SWFLoader.loadedBytes);
    }
    public static function set percent(p:uint):void {
      SWFLoader.per = p;
    }
    public static function get percent():uint {
      return (SWFLoader.per);
    }
    public static function set loadProgressBar(b:Boolean):void {
      SWFLoader.isLoadProgressBar = b;
    }
    public static function get loadProgressBar():Boolean {
      return (SWFLoader.isLoadProgressBar);
    }
    public static function set loadProgressBarFilter(b:Boolean):void {
      SWFLoader.isLoadProgressBarFilter = b;
    }
    public static function get loadProgressBarFilter():Boolean {
      return (SWFLoader.isLoadProgressBarFilter);
    }
    public static function set loadProgressIcon(b:Boolean):void {
      SWFLoader.isLoadProgressIcon = b;
    }
    public static function get loadProgressIcon():Boolean {
      return (SWFLoader.isLoadProgressIcon);
    }
    public static function set loadProgressPercent(b:Boolean):void {
      SWFLoader.isLoadProgressPercent = b;
    }
    public static function get loadProgressPercent():Boolean {
      return (SWFLoader.isLoadProgressPercent);
    }
    public static function set barColor($color:uint):void {
      SWFLoader.loadProgressBarColor = $color;
    }
    public static function get barColor():uint {
      return (SWFLoader.loadProgressBarColor);
    }
    public static function set baseColor($color:uint):void {
      SWFLoader.loadProgressBaseColor = $color;
    }
    public static function get baseColor():uint {
      return (SWFLoader.loadProgressBaseColor);
    }
    public static function set x($x:int):void {
      SWFLoader.loadProgressX = $x;
    }
    public static function get x():int {
      return (SWFLoader.loadProgressX);
    }
    public static function set y($y:int):void {
      SWFLoader.loadProgressY = $y;
    }
    public static function get y():int {
      return (SWFLoader.loadProgressY);
    }
    public static function set width($width:uint):void {
      SWFLoader.loadProgressWidth = $width;
    }
    public static function get width():uint {
      return (SWFLoader.loadProgressWidth);
    }
    public static function set height($height:uint):void {
      SWFLoader.loadProgressHeight = $height;
    }
    public static function get height():uint {
      return (SWFLoader.loadProgressHeight);
    }
    public static function set rectangle($rectangle:Rectangle):void {
      SWFLoader.loadProgressRectangle = $rectangle;
    }
    public static function get rectangle():Rectangle {
      return (SWFLoader.loadProgressRectangle);
    }
    public static function set filterColor($color:uint):void {
      SWFLoader.loadProgressFilterColor = $color;
    }
    public static function get filterColor():uint {
      return (SWFLoader.loadProgressFilterColor);
    }
    public static function set filterAlpha($alpha:Number):void {
      SWFLoader.loadProgressFilterAlpha = $alpha;
    }
    public static function get filterAlpha():Number {
      return (SWFLoader.loadProgressFilterAlpha);
    }
    public static function set filterBlurX($blurX:Number):void {
      SWFLoader.loadProgressFilterBlurX = $blurX;
    }
    public static function get filterBlurX():Number {
      return (SWFLoader.loadProgressFilterBlurX);
    }
    public static function set filterBlurY($blurY:Number):void {
      SWFLoader.loadProgressFilterBlurY = $blurY;
    }
    public static function get filterBlurY():Number {
      return (SWFLoader.loadProgressFilterBlurY);
    }
    public static function set filterStrength($strength:Number):void {
      SWFLoader.loadProgressFilterStrength = $strength;
    }
    public static function get filterStrength():Number {
      return (SWFLoader.loadProgressFilterStrength);
    }
    public static function set filterQuality($quality:Number):void {
      SWFLoader.loadProgressFilterStrength = $quality;
    }
    public static function get filterQuality():Number {
      return (SWFLoader.loadProgressFilterQuality);
    }
    public static function set filterInner($inner:Boolean):void {
      SWFLoader.loadProgressFilterInner = $inner;
    }
    public static function get filterInner():Boolean {
      return (SWFLoader.loadProgressFilterInner);
    }
    public static function set filterKnockout($knockout:Boolean):void {
      SWFLoader.loadProgressFilterKnockout = $knockout;
    }
    public static function get filterKnockout():Boolean {
      return (SWFLoader.loadProgressFilterKnockout);
    }
    public static function set percentFont($font:String):void {
      SWFLoader.loadProgressPercentFont = $font;
    }
    public static function get percentFont():String {
      return (SWFLoader.loadProgressPercentFont);
    }
    public static function set percentFontSize($fontSize:uint):void {
      SWFLoader.loadProgressPercentFontSize = $fontSize;
    }
    public static function get percentFontSize():uint {
      return (SWFLoader.loadProgressPercentFontSize);
    }
    public static function set percentFontColor($fontColor:uint):void {
      SWFLoader.loadProgressPercentFontColor = $fontColor;
    }
    public static function get percentFontColor():uint {
      return (SWFLoader.loadProgressPercentFontColor);
    }
  }
}
import flash.display.Sprite;
import flash.display.MovieClip;
import flash.display.Shape;
import flash.geom.Rectangle;
import flash.text.TextField;
import flash.text.TextFormat;
import flash.filters.BitmapFilterQuality;
import flash.filters.GlowFilter;
internal class LoadProgress extends Sprite {
  public var bar:Sprite = new Sprite();
  public var base:Sprite = new Sprite();
  private var barShape:Shape;
  private var baseShape:Shape;
  public var icon:MovieClip;
  public var percent:Sprite = new Sprite();
  private var percentText:TextField = new TextField();
  private var percentTextFormat:TextFormat = new TextFormat();
  public function LoadProgress(
      barColor:uint,
      baseColor:uint,
      barRectangle:Rectangle,
      filterColor:uint,
      filterAlpha:Number,
      filterBlurX:Number,
      filterBlurY:Number,
      filterStrength:Number,
      filterQuality:Number,
      filterInner:Boolean,
      filterKnockout:Boolean,
      percentFont:String,
      percentFontSize:uint,
      percentFontColor:uint,
      isLoadProgressBar:Boolean,
      isLoadProgressBarFilter:Boolean,
      isLoadProgressIcon:Boolean,
      isLoadProgressPercent:Boolean
   ):void {
    if (isLoadProgressBar) {
      barShape = drawnShape(barColor,barRectangle);
      baseShape = drawnShape(baseColor,barRectangle);
      addLoadProgressBar(base, baseShape, "baseShape", this.numChildren,barRectangle);
      addLoadProgressBar(bar, barShape, "barShape", this.numChildren,barRectangle);
      if (isLoadProgressBarFilter) {
        setLoadProgressBarFilter(bar, 
            glowFilter(
                filterColor, 
                filterAlpha, 
                filterBlurX, 
                filterBlurY, 
                filterStrength, 
                filterQuality, 
                filterInner, 
                filterKnockout
            )
        );
      }
      initLoadProgressBarScale(bar, 0);
    }
    if (isLoadProgressIcon) {
      addLoadProgressIcon("icon", this.numChildren);
    }
    if (isLoadProgressPercent) {
      addLoadProgressPercent(percent, percentText, "percentText", this.numChildren);
      setPercentTextFormat(percentFont, percentFontSize, percentFontColor);
      setPercentTextField();
    }
  }
  private function drawnShape($color:uint, $rectangle:Rectangle):Shape {
    var shape:Shape = new Shape();
    shape.graphics.beginFill($color);
    shape.graphics.drawRect(0,0,$rectangle.width,$rectangle.height);
    return Shape(shape);
  }
  private function addLoadProgressBar($parent:Sprite, $child:Shape, $name:String, $depth:int, $rectangle:Rectangle):void {
    this.addChildAt($parent, $depth);
    $parent.x = $rectangle.x;
    $parent.y = $rectangle.y;
    $parent.addChildAt($child, 0);
    $child.name = $name;
  }
  private function setLoadProgressBarFilter($bar:Sprite, $filters:GlowFilter):void {
    $bar.filters = [$filters];
  }
  private function initLoadProgressBarScale($bar:Sprite, $scaleX:Number):void {
    $bar.scaleX = $scaleX;
  }
  private function addLoadProgressIcon($name:String, $depth:int):void {
    //下記の行でライブラリのリンケージクラス
    //「LoadProgressIcon」を呼び出しています
    icon = new LoadProgressIcon();
    this.addChildAt(icon, $depth);
    icon.name = $name;
  }
  private function addLoadProgressPercent($parent:Sprite, $child:TextField, $name:String, $depth:int):void {
    this.addChildAt($parent, $depth);
    $parent.addChildAt($child, 0);
    $child.name = $name;
  }
  private function setPercentTextFormat(font:String, size:uint, color:uint):void {
    percentTextFormat.font = font;
    percentTextFormat.size = size;
    percentTextFormat.color = color;
  }
  private function setPercentTextField():void {
    percentText.autoSize = "left";
    percentText.multiline = false;
    percentText.wordWrap = false;
    percentText.selectable = false;
    percentText.mouseWheelEnabled = false;
    percentText.defaultTextFormat = percentTextFormat;
    percentText.text = String(0);
  }
  private function glowFilter(
      color:uint=0xFFFFFF, 
      alpha:Number=.8, 
      blurX:Number=2, 
      blurY:Number=2, 
      strength:Number=2, 
      quality:Number=BitmapFilterQuality.HIGH, 
      inner:Boolean=false, 
      knockout:Boolean=false
  ):GlowFilter {
    return new GlowFilter(
        color,
        alpha,
        blurX,
        blurY,
        strength,
        quality,
        inner,
        knockout
    );
  }
}

【サンプルソースコード: preloader.swf】

Preloader.as

package {
  import flash.display.MovieClip;
  import flash.display.Sprite;
  import flash.display.StageAlign;
  import flash.display.StageScaleMode;
  import flash.geom.Rectangle;
  import flash.filters.BitmapFilterQuality;
  import flash.utils.Timer;
  import flash.events.TimerEvent;
  import flash.events.Event;
  import jp.atziluth.system.SWFLoader;
  public class Preloader extends SWFLoader {
    //SWFLoaderを mainLoaderとして定義
    private var mainLoader:MovieClip = new SWFLoader();
    //ロード開始時に実行する関数
    private var onLoadFunction:Function = function(){Preloader.loadProgressLayout()};
    //ロード完了時に実行する関数
    private var onCompleteFunction:Function = function(){};
    //ロードするファイルのアルファ(初期値)
    private var childDefAlpha:Number = 0;
    //ロード状況表示エリアのアルファ(初期値)
    private var loadProgressDefAlpha:Number = 1;
    //プログレスバーを表示するかどうか
    private var isLoadProgressBar:Boolean = true;
    //プログレスバーにグローフィルタを適用するかどうか
    private var isLoadProgressBarFilter:Boolean = true;
    //ローディングアイコンを表示するかどうか
    private var isLoadProgressIcon:Boolean = true;
    //パーセントテキストを表示するかどうか
    private var isLoadProgressPercent:Boolean = false;
    //ロード開始までの遅延時間(秒数)
    private var delaySecond:Number = 0;
    //ライブラリのリンケージクラス 「AddedLoadClip」の呼び出し(このサンプルでは未使用)
    //private var addedLoadClip:Sprite = new AddedLoadClip();
    public function Preloader():void {
      stage.scaleMode = StageScaleMode.NO_SCALE;
      stage.align = StageAlign.TOP_LEFT;
      stage.frameRate = 60;
      stage.addEventListener(Event.RESIZE,onStageResize);
      initLoadProgress();
      mainLoader.load(
          this,
          "main.swf",
          onLoadFunction,
          onCompleteFunction,
          childDefAlpha,
          loadProgressDefAlpha,
          delaySecond,
          isLoadProgressBar,
          isLoadProgressBarFilter,
          isLoadProgressIcon,
          isLoadProgressPercent
      );
       /*--------------------------------------------------------------------------
      * Trace getter
      *--------------------------------------------------------------------------*/
       /*
      tracer();
      setTraceTimer();
      startTraceTimer();
      */
    }
    private function onStageResize(event:Event):void {
      Preloader.loadProgressLayout();
    }
    private static const ICON_SIZE:uint = 24;
    public static function loadProgressLayout():void {
      with (SWFLoader.currentLoadProgress) {
        //ロード状況表示エリアの配置
        x = 0;
        y = 0;
        if (SWFLoader.loadProgressBar) {
          //プログレスバーの配置
          bar.x = 0;
          bar.y = Math.round(stage.stageHeight / 2 - bar.height / 2);
          bar.getChildByName("barShape").width = stage.stageWidth;
          //プログレスバー(背景)の配置
          base.x = 0;
          base.y = bar.y;
          base.getChildByName("baseShape").width = bar.getChildByName("barShape").width;
        }
        if (SWFLoader.loadProgressIcon) {
          //ローディングアイコンの配置
          icon.x = Math.round(stage.stageWidth / 2 - Preloader.ICON_SIZE / 2);
          if (SWFLoader.loadProgressBar) {
            icon.y = Math.round(bar.y + Preloader.ICON_SIZE);
          } else {
            icon.y = Math.round(stage.stageHeight / 2 - Preloader.ICON_SIZE / 2);
          }
        }
        if (SWFLoader.loadProgressPercent) {
          //パーセントテキストの配置
          percent.x = 0;
          percent.y = 0;
        }
      }
    }
    private function initLoadProgress():void {
      //プログレスバーの色
      SWFLoader.barColor = 0xFFFFFF;
      //プログレスバーの背景色
      SWFLoader.baseColor = 0x333333;
      //プログレスバーの横位置
      SWFLoader.x = 0;
      //プログレスバーの縦位置
      SWFLoader.y = 0;
      //プログレスバーの横幅
      SWFLoader.width = stage.stageWidth;
      //プログレスバーの縦幅
      SWFLoader.height = 1;
      //プログレスバーの位置とサイズを Rectangle指定 (こちらが優先される)
      //SWFLoader.rectangle = new Rectangle(0,0,stage.stageWidth,1);
      //グローフィルタの色
      SWFLoader.filterColor = 0xFFFFFF;
      //グローフィルタのアルファ透明度
      SWFLoader.filterAlpha = .8;
      //グローフィルタの水平方向のぼかし量
      SWFLoader.filterBlurX = 2;
      //グローフィルタの垂直方向のぼかし量
      SWFLoader.filterBlurY = 2;
      //グローフィルタのインプリントの強さ
      SWFLoader.filterStrength = 2;
      //グローフィルタを適用する回数
      SWFLoader.filterQuality = BitmapFilterQuality.HIGH;
      //グローフィルタが内側グローであるかどうか
      SWFLoader.filterInner = false;
      //グローフィルタを適用するオブジェクトにノックアウト効果を付加するかどうか
      SWFLoader.filterKnockout = false;
      //パーセントテキストのフォント
      SWFLoader.percentFont = "_serif";
      //パーセントテキストのフォントサイズ
      SWFLoader.percentFontSize = 12;
      //パーセントテキストのフォントカラー
      SWFLoader.percentFontColor = 0xFFFFFF;
    }
    private var traceTimer:Timer = new Timer(1000,0);
    private function setTraceTimer():void {
      traceTimer.addEventListener(TimerEvent.TIMER, tracer);
    }
    private function startTraceTimer():void {
      traceTimer.start();
    }
    private function tracer(event:TimerEvent=null):void {
      trace("---------------------------------------------");
      trace("SWFLoader.loading"+": "+SWFLoader.loading);
      trace("SWFLoader.complete"+": "+SWFLoader.complete);
      trace("SWFLoader.bytesTotal"+": "+SWFLoader.bytesTotal);
      trace("SWFLoader.bytesLoaded"+": "+SWFLoader.bytesLoaded);
      trace("SWFLoader.percent"+": "+SWFLoader.percent);
      trace("SWFLoader.loadProgressBar"+": "+SWFLoader.loadProgressBar);
      trace("SWFLoader.loadProgressBarFilter"+": "+SWFLoader.loadProgressBarFilter);
      trace("SWFLoader.loadProgressIcon"+": "+SWFLoader.loadProgressIcon);
      trace("SWFLoader.loadProgressPercent"+": "+SWFLoader.loadProgressPercent);
      trace("SWFLoader.barColor"+": "+SWFLoader.barColor);
      trace("SWFLoader.baseColor"+": "+SWFLoader.baseColor);
      trace("SWFLoader.x"+": "+SWFLoader.x);
      trace("SWFLoader.y"+": "+SWFLoader.y);
      trace("SWFLoader.width"+": "+SWFLoader.width);
      trace("SWFLoader.height"+": "+SWFLoader.height);
      trace("SWFLoader.rectangle"+": "+SWFLoader.rectangle);
      trace("SWFLoader.filterColor"+": "+SWFLoader.filterColor);
      trace("SWFLoader.filterAlpha"+": "+SWFLoader.filterAlpha);
      trace("SWFLoader.filterBlurX"+": "+SWFLoader.filterBlurX);
      trace("SWFLoader.filterBlurY"+": "+SWFLoader.filterBlurY);
      trace("SWFLoader.filterStrength"+": "+SWFLoader.filterStrength);
      trace("SWFLoader.filterQuality"+": "+SWFLoader.filterQuality);
      trace("SWFLoader.filterInner"+": "+SWFLoader.filterInner);
      trace("SWFLoader.filterKnockout"+": "+SWFLoader.filterKnockout);
      trace("SWFLoader.percentFont"+": "+SWFLoader.percentFont);
      trace("SWFLoader.percentFontSize"+": "+SWFLoader.percentFontSize);
      trace("SWFLoader.percentFontColor"+": "+SWFLoader.percentFontColor);
      trace("---------------------------------------------"+"\n");
    }
  }
}

【サンプルソースコード: main.swf】

Main.as

package {
  import flash.display.Sprite;
  import flash.display.MovieClip;
  import flash.display.StageAlign;
  import flash.display.StageScaleMode;
  import flash.events.Event;
  import jp.atziluth.gui.RelativeLayout;
  public class Main extends MovieClip {
    private const COMPLETE:Sprite = new Complete();
    public function Main():void {
      super();
      this.addEventListener(Event.ADDED_TO_STAGE, init);
    }
    private function init(event:Event):void {
      this.removeEventListener(Event.ADDED_TO_STAGE, init);
      stage.scaleMode = StageScaleMode.NO_SCALE;
      stage.align = StageAlign.TOP_LEFT;
      stage.addEventListener(Event.RESIZE,onStageResize);
      this.addChild(COMPLETE);
      lauoutMain();
    }
    private function onStageResize(event:Event):void {
      lauoutMain();
    }
    private function lauoutMain():void {
      RelativeLayout.setPos(stage, COMPLETE);
    }
  }
}

Download

*1:\src\jp\atziluth\system\SWFLoader.as:
  455行目でライブラリのリンケージクラス「LoadProgressIcon」(ローディングアイコン)を読み込んでいます

*2:\src\jp\atziluth\system\SWFLoader.as:
  SWFLoaderのアニメーションには Tweenerクラスが必要になります
  Tweener: http://www.tonpoo.com/tweener/index2.html

2010.02.06

AS3で配列/数値のシャッフルや乱数生成を行う「Randomize」クラス

Randomize

Randomize

ActionScript3.0で配列/数値のシャッフルや乱数生成を行う「Randomize」クラスを作成しました。

静的クラスメンバ“shuffleArray”は指定した配列要素の順序をシャッフルして返し、静的クラスメンバ“shuffle”は指定した範囲内の数値をシャッフルし配列として返します。*1

静的クラスメンバ“exactRandom”は除外指定した数値以外の乱数を返し、静的クラスメンバ“range”は指定した範囲内の乱数を返します。

下記のボタンより、サンプルの閲覧およびソースのダウンロードができます。

Sample Download

【使用例】

myArrayの要素をシャッフルし、shuffledArrayへ代入する

var myArray:Array = [1, 3, 5, 7, 9]
var shuffledArray:Array = Randomize.shuffleArray(myArray);

1〜12までの数値をシャッフルし、

12個の要素を持つ配列として shuffledArrayへ代入する

var shuffleMin:uint = 1;
var shuffleMax:uint = 12;
var shuffledArray:Array = Randomize.shuffle(shuffleMin, shuffleMax);

1〜12までの乱数を取得し、myUintへ代入する

(ただし exceptUintと同じ数値である 1は返らない)

var exceptUint:uint = 1;
var randomMin:uint = 1;
var randomMax:uint = 12;
var myUint:uint = 
  Randomize.exactRandom(exceptUint, randomMin, randomMax);

1〜12までの乱数を取得し、myUintへ代入する

var randomMin:uint = 1;
var randomMax:uint = 12;
var myUint:uint = 
  Randomize.range(randomMin, randomMax);

【パラメータ説明: “shuffleArray”】

arr

要素の順序をシャッフルする配列
[Array][省略不可]

【パラメータ説明: “shuffle”】

shuffleMin

シャッフルする数値の最小値
[int][省略不可]

shuffleMax

シャッフルする数値の最大値
[int][省略不可]

【パラメータ説明: “exactRandom”】

exceptInt

戻り値の乱数から除外する数値
[int][省略不可]

randomMin

乱数の最小値
[int][省略不可]

randomMax

乱数の最大値
[int][省略不可]

【パラメータ説明: “range”】

randomMin

乱数の最小値
[int][省略不可]

randomMax

乱数の最大値
[int][省略不可]

ソースコード

import jp.atziluth.utils.Randomize;

package jp.atziluth.utils{
  public class Randomize {
    private static var shuffleList:Array = [];
    private static var shuffleNum:uint;
    private static var tempList:Array = [];
    private static var tempInt:int;
    public static function shuffleArray(arr:Array):Array {
      Randomize.shuffleList = arr;
      Randomize.shuffleNum = Randomize.shuffleList.length;
      while (Randomize.shuffleNum) {
        var m:int = Math.floor(Math.random() * Randomize.shuffleNum);
        var n:int = Randomize.shuffleList[--Randomize.shuffleNum];
        Randomize.shuffleList[Randomize.shuffleNum] = Randomize.shuffleList[m];
        Randomize.shuffleList[m] = n;
      }
      return (Randomize.shuffleList);
    }
    public static function shuffle(shuffleMin:int, shuffleMax:int):Array {
      for (var i:uint; i<shuffleMax; i++) {
        Randomize.tempList[i] = i + shuffleMin;
      }
      Randomize.shuffleList = Randomize.shuffleArray(Randomize.tempList);
      return (Randomize.shuffleList);
    }
    public static function exactRandom(exceptInt:int, randomMin:int, randomMax:int):int {
      do {
        Randomize.tempInt = Randomize.range(randomMin,randomMax);
      } while (Randomize.tempInt==exceptInt);
      return (Randomize.tempInt);
    }
    public static function range(randomMin:int, randomMax:int):int {
      var i:int = Math.floor(Math.random()*(randomMax-randomMin+1))+randomMin;
      return (i);
    }
  }
}

【サンプルソースコード】

Sample.as

package {
  import flash.display.Sprite;
  import flash.display.StageAlign;
  import flash.display.StageScaleMode;
  import flash.utils.Timer;
  import flash.events.TimerEvent;
  import flash.events.Event;
  import flash.text.TextField;
  import flash.text.TextFormat;
  import jp.atziluth.gui.RelativeLayout;
  import jp.atziluth.utils.Randomize;
  [SWF(width=420, height=262, backgroundColor=0x000000, frameRate=12)]
  public class Sample extends Sprite {
    //シャッフルする配列
    internal var myArray:Array = [111,222,333,444,555,666,777,888,999];
    //シャッフル・ランダム出力する値の最大値
    internal var randomizeMax:int = myArray.length;
    //シャッフル・ランダム出力の最大値
    internal var randomizeMin:int = 1;
    //ランダム出力で除外する数値
    internal var randomizeExcept:int;
    private var randomizeTimer:Timer = new Timer(3000,0);
    protected var randomizeTimerCount:uint = 1;
    protected var resultExpression:Sprite = new Sprite();
    private var resultTextField:TextField = new TextField();
    private var resultTextFormat:TextFormat = new TextFormat();
    public function Sample():void {
      //ステージのプロパティ登録
      setStageProperty();
      //ステージのイベントリスナー登録
      setStageEvents();
      //出力結果を表示するコンテナの追加
      addResultExpression();
      //テキストフィールドのフォーマット設定
      setResultTextFormat();
      //テキストフィールドの設定および出力結果の代入
      setResultTextField();
      //テキストフィールドをコンテナへ追加
      addResultTextField();
      //1度目のトレース出力
      traceRandomizeResult();
      //出力結果を一定間隔で更新するタイマーの定義
      setRandomizeTimer();
      //タイマー開始
      startRandomizeTimer();
      //予めコンテナのレイアウトを1度実行する
      centeringLayout();
    }
    internal function setStageProperty():void {
      //ステージの伸縮を「拡大・縮小なし」に設定
      stage.scaleMode = StageScaleMode.NO_SCALE;
      //ステージの位置を「左上」に設定
      stage.align = StageAlign.TOP_LEFT;
    }
    private function setStageEvents():void {
      //ステージリサイズ時のイベントリスナー登録
      stage.addEventListener(Event.RESIZE,centeringLayout);
    }
    private function addResultExpression():void {
      addChildAt(resultExpression, 0);
    }
    private function setResultTextFormat():void {
      resultTextFormat.font = "_sans";
      resultTextFormat.color = 0xFFFFFF;
      resultTextFormat.size = 12;
      resultTextFormat.leading = 4;
    }
    private function setResultTextField():void {
      resultTextField.autoSize = "left";
      resultTextField.multiline = true;
      resultTextField.wordWrap = false;
      resultTextField.selectable = false;
      resultTextField.mouseWheelEnabled = false;
      resultTextField.defaultTextFormat = resultTextFormat;
      resultExpressionText = result;
    }
    private function addResultTextField():void {
      resultExpression.addChildAt(resultTextField,0);
    }
    private function set resultExpressionText(resultStr:String):void {
      resultTextField.htmlText = resultStr;
    }
    internal function get result():String {
      return (
        "---------------------------------------------------------------------------------------------"+"\n"+
        "[Fase: "+randomizeTimerCount+"]"+"\n"+
        "Randomize.shuffleArray: "+
          Randomize.shuffleArray(myArray)+"\n"+
        "Randomize.shuffle: "+
          Randomize.shuffle(randomizeMin, randomizeMax)+"\n"+
        "Randomize.exactRandom: "+
          Randomize.exactRandom(
            randomizeExcept, 
            randomizeMin, 
            randomizeMax
          )+"\n"+
        "Randomize.range: "+
          Randomize.range(
            randomizeMin, 
            randomizeMax
          )+"\n"+
        "---------------------------------------------------------------------------------------------"
      );
    }
    private function traceRandomizeResult():void {
      trace(result);
    }
    private function setRandomizeTimer():void {
      randomizeTimer.addEventListener(TimerEvent.TIMER, displayRandomizeResult);
    }
    private function startRandomizeTimer():void {
      randomizeTimer.start();
    }
    private function displayRandomizeResult(event:TimerEvent):void {
      //タイマーが実行された回数を randomizeTimerCountへ代入
      randomizeTimerCount = event.target.currentCount + 1;
      //トレース出力
      traceRandomizeResult();
      //テキストフィールド更新
      resultExpressionText = result;
    }
    protected function centeringLayout(event:Event=null):void {
      //コンテナをステージ中央へ配置
      RelativeLayout.setPos(stage, resultExpression, "cm");
    }
  }
}

Download

*1:シャッフルの方式には Fisher-Yatesのアルゴリズムを使用しています