チェンジセット 4437

差分発生行の前後
無視リスト:
コミット日時:
2010/12/06 19:52:04 (1 年前)
コミッタ:
kuboh
ログメッセージ:

--

ファイル:

凡例:

変更無し
追加
削除
更新
コピー
移動
  • as2/ButtonGroupManager/src/ButtonGroupManager.as

    r3101 r4437  
    11/*-------------------- 
    2  ボタングループ管理 AS2版 v1.0 
     2 ボタングループ管理 AS2版 v1.1 
    33 kUBoh 2009/09/11 
    44 
     5 v1.1:同じ名前でaddActionした場合、同名の古いアクションを削除するように変更...2009/10/15 
     6 
    57/* 
    6         ・使い方: 
    7          -TweenMaxにパスが通っている必要があります。 
    8                 ※TweenMaxはデフォルトのボタンエフェクトを付ける為にのみ使用しています。 
    9          
    10                ■ボタンの設定方法 
    11                 -1.ライブラリ内のムービークリップに、リンケージ>クラスから設定する場合: 
    12                        ライブラリ内のムービークリップに、リンケージ>クラスから設定する。設定パネルの「クラス」に"ButtonGroupManager"を設定。 
    13                 -2.ASから設定する場合: 
    14                        new ButtonGroupManager( tgt:MovieClip, tgtGroupName:String [,isCopyDefaults:Boolean] );を実行 
    15                                【引数】 
    16                                tgt:対象のムービークリップ 
    17                                tgtGroupName:所属するグループ名(存在しないグループ名を指定した場合、新たにそのグループ名が作られます。) 
    18                                isCopyDefaults:インスタンス単体(グループに所属しない)動作時の為のボタンイベント群の初期値として、デフォルトのボタンイベント群をコピーするか(オプション) 
    19                  
    20                 -ボタンのヒットエリア: 
    21                 上記の設定をButtonGroupManagerを適用した表示オブジェクト内にヒットエリアになる表示オブジェクトを"hitAreaBase"という名前で配置しておく。 
    22                 ※存在しない場合は透明の矩形を自動で生成します。 
    23                  
    24                  
    25                 -その他のプロパティ 
    26                         group         :インスタンスが所属するグループ(文字列)。未設定または指定グループが存在しない場合はインスタンス自身に設定されたボタンイベント群を実行する 
    27  
    28  
    29  
    30  
    31  
    32                ■グループの追加(静的関数) 
    33                addGroup ( groupName:String ,isCopyDefaults:Boolean ):Void 
    34                 グループを当クラスのグループリストに追加します。 
    35                        【引数】 
    36                         -groupName:追加するグループ名(文字列) 
    37                         -isCopyDefaults:そのグループにデフォルトのボタンイベント群をコピーするか(オプション) 
    38                  
    39                ■グループの削除(静的関数) 
    40                removeGroup ( groupName:String ):Void 
    41                 グループを当クラスのグループリストから削除します。 
    42                        【引数】 
    43                         -groupName:削除するグループ名(文字列) 
    44                          
    45                ■ボタンイベントの追加(静的関数) 
    46                addAction ( type:String ,actionName:String, action:Function, groupName:String):String 
    47                 指定したグループに指定したタイプのボタンイベントを登録します。 
    48                        【引数】 
    49                         -type:登録するボタンイベントのタイプ(文字列) 
    50                          →次の6つから指定してください。"rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside" 
    51                         -actionName:登録する関数を識別する為の名前(文字列) 
    52                          →登録&実行時には必要有りませんが、指定しないと削除時に困ります。undefined,null,""を指定するとルールに従って自動で設定されます。 
    53                         -action:登録する関数本体 
    54                         -groupName:登録するグループ名(文字列) 
    55                          →未指定の場合や、指定したグループが存在しない場合、この関数は実行されません。 
    56                        【戻り値】 
    57                         登録されたボタンアクションに付けられた関数名(文字列) 
    58                          
    59                ■ボタンイベントの削除(静的関数) 
    60                removeAction ( type:String ,actionName:String, groupName:String ):Boolean 
    61                 指定したグループ&タイプのボタンイベントから指定した名前の関数を削除します。 
    62                        【引数】 
    63                         -type:削除する関数が登録されているボタンイベントのタイプ(文字列) 
    64                          →次の6つから指定してください。"rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside" 
    65                         -actionName:削除する関数名(文字列) 
    66                         -groupName:削除する関数が登録されているグループ(文字列) 
    67                        【戻り値】 
    68                         削除に成功した場合true、何らかの理由で削除出来なかった場合はfalseがかえされます。                  
    69                          
    70                          
    71                ■インスタンス固有ボタンイベントの追加 
    72                addInstanceAction ( type:String ,actionName:String, action:Function):String 
    73                 インスタンスに指定したタイプのボタンイベントを登録します。インスタンスのgroupプロパティが未設定の場合に実行されます。 
    74                        【引数】 
    75                         -type:登録するボタンイベントのタイプ(文字列) 
    76                          →次の6つから指定してください。"rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside" 
    77                         -actionName:登録する関数を識別する為の名前(文字列) 
    78                          →登録&実行時には必要有りませんが、指定しないと削除時に困ります。undefined,null,""を指定するとルールに従って自動で設定されます。 
    79                         -action:登録する関数本体                       
    80                        【戻り値】 
    81                         登録されたボタンアクションに付けられた関数名(文字列) 
    82                          
    83                ■インスタンス固有ボタンイベントの削除 
    84                removeInstanceAction ( type:String ,actionName:String ):Boolean 
    85                 指定したタイプのボタンイベントから指定した名前の関数を削除します。 
    86                        【引数】 
    87                         -type:削除する関数が登録されているボタンイベントのタイプ(文字列) 
    88                          →次の6つから指定してください。"rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside" 
    89                         -actionName:削除する関数名(文字列) 
    90                        【戻り値】 
    91                         削除に成功した場合true、何らかの理由で削除出来なかった場合はfalseがかえされます。                                          
    92                          
     8 ・使い方: 
     9  -TweenMaxにパスが通っている必要があります。 
     10 ※TweenMaxはデフォルトのボタンエフェクトを付ける為にのみ使用しています。 
     11 
     12■ボタンの設定方法 
     13 -1.ライブラリ内のムービークリップに、リンケージ>クラスから設定する場合: 
     14ライブラリ内のムービークリップに、リンケージ>クラスから設定する。設定パネルの「クラス」に"ButtonGroupManager"を設定。 
     15 -2.ASから設定する場合: 
     16new ButtonGroupManager( tgt:MovieClip, tgtGroupName:String [,isCopyDefaults:Boolean] );を実行 
     17【引数】 
     18tgt:対象のムービークリップ 
     19tgtGroupName:所属するグループ名(存在しないグループ名を指定した場合、新たにそのグループ名が作られます。) 
     20isCopyDefaults:インスタンス単体(グループに所属しない)動作時の為のボタンイベント群の初期値として、デフォルトのボタンイベント群をコピーするか(オプション) 
     21 
     22 -ボタンのヒットエリア: 
     23 上記の設定をButtonGroupManagerを適用した表示オブジェクト内にヒットエリアになる表示オブジェクトを"hitAreaBase"という名前で配置しておく。 
     24 ※存在しない場合は透明の矩形を自動で生成します。 
     25 
     26 
     27 -その他のプロパティ 
     28 group                :インスタンスが所属するグループ(文字列)。未設定または指定グループが存在しない場合はインスタンス自身に設定されたボタンイベント群を実行する 
     29 
     30 
     31 
     32 
     33 
     34■グループの追加(静的関数) 
     35addGroup ( groupName:String ,isCopyDefaults:Boolean ):Void 
     36 グループを当クラスのグループリストに追加します。 
     37【引数】 
     38 -groupName:追加するグループ名(文字列) 
     39 -isCopyDefaults:そのグループにデフォルトのボタンイベント群をコピーするか(オプション) 
     40  
     41■グループの削除(静的関数) 
     42removeGroup ( groupName:String ):Void 
     43 グループを当クラスのグループリストから削除します。 
     44【引数】 
     45 -groupName:削除するグループ名(文字列) 
     46 
     47■ボタンイベントの追加(静的関数) 
     48addAction ( type:String ,actionName:String, action:Function, groupName:String):String 
     49 指定したグループに指定したタイプのボタンイベントを登録します。 
     50【引数】 
     51 -type:登録するボタンイベントのタイプ(文字列) 
     52  →次の6つから指定してください。"rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside" 
     53 -actionName:登録する関数を識別する為の名前(文字列) 
     54  →登録&実行時には必要有りませんが、指定しないと削除時に困ります。undefined,null,""を指定するとルールに従って自動で設定されます。 
     55 -action:登録する関数本体 
     56 -groupName:登録するグループ名(文字列) 
     57  →未指定の場合や、指定したグループが存在しない場合、この関数は実行されません。 
     58【戻り値】 
     59 登録されたボタンアクションに付けられた関数名(文字列) 
     60 
     61■ボタンイベントの削除(静的関数) 
     62removeAction ( type:String ,actionName:String, groupName:String ):Boolean 
     63 指定したグループ&タイプのボタンイベントから指定した名前の関数を削除します。 
     64【引数】 
     65 -type:削除する関数が登録されているボタンイベントのタイプ(文字列) 
     66  →次の6つから指定してください。"rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside" 
     67 -actionName:削除する関数名(文字列) 
     68 -groupName:削除する関数が登録されているグループ(文字列) 
     69【戻り値】 
     70 削除に成功した場合true、何らかの理由で削除出来なかった場合はfalseがかえされます。                         
     71 
     72 
     73■インスタンス固有ボタンイベントの追加 
     74addInstanceAction ( type:String ,actionName:String, action:Function):String 
     75 インスタンスに指定したタイプのボタンイベントを登録します。インスタンスのgroupプロパティが未設定の場合に実行されます。 
     76【引数】 
     77 -type:登録するボタンイベントのタイプ(文字列) 
     78  →次の6つから指定してください。"rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside" 
     79 -actionName:登録する関数を識別する為の名前(文字列) 
     80  →登録&実行時には必要有りませんが、指定しないと削除時に困ります。undefined,null,""を指定するとルールに従って自動で設定されます。 
     81 -action:登録する関数本体                      
     82【戻り値】 
     83 登録されたボタンアクションに付けられた関数名(文字列) 
     84 
     85■インスタンス固有ボタンイベントの削除 
     86removeInstanceAction ( type:String ,actionName:String ):Boolean 
     87 指定したタイプのボタンイベントから指定した名前の関数を削除します。 
     88【引数】 
     89 -type:削除する関数が登録されているボタンイベントのタイプ(文字列) 
     90  →次の6つから指定してください。"rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside" 
     91 -actionName:削除する関数名(文字列) 
     92【戻り値】 
     93 削除に成功した場合true、何らかの理由で削除出来なかった場合はfalseがかえされます。                                                 
     94 
    9395--------------------*/ 
    94  
    9596//TweenMaxクラスインポート 
    9697import gs.TweenMax; 
    9798import gs.easing.*; 
    98  
    9999//ボタン設定本体 
    100100class ButtonGroupManager extends MovieClip 
    101101{ 
    102  
    103          
    104102        /*-------------------- 
    105103         クラス共通のパラメータ 
    106104        --------------------*/ 
    107105        //グループ管理用配列 
    108         public static var groups:Array ; 
    109          
     106        public static var groups:Array; 
    110107        //関数に名前を付けなかった場合に関数名につける連番 
    111108        private static var counter:Number; 
    112          
    113109        //インスタンス単位の関数を格納する配列 
    114110        private var actions:Array; 
    115          
    116111        //このクラスで管理しているボタンの参照リスト 
    117112        private static var buttonList:Array; 
    118          
    119113        //デフォルトグループ名(変更可) 
    120114        public static var DEFAULT_GROUP_NAME:String = "DEFAULT"; 
    121  
    122115        //デフォルトのボタンエフェクト(変更可) 
    123116        public static var DEFAULT_DURATION:Number = .3; 
    124          
    125117        //アクションタイプ名チェック用リスト 
    126118        private static var ACTION_TYPE_NAMES:Array = new Array("rollOver", "rollOut", "dragOut", "press", "release", "releaseOutside"); 
    127  
    128119        //初期化済み? 
    129120        private static var firstRun:Boolean = true; 
    130          
    131121        //デフォルトのアクション群 
    132         private static var DEFAULT_ACTION_ROLLOVER:Function  
    133         private static var DEFAULT_ACTION_ROLLOUT:Function 
    134         private static var DEFAULT_ACTION_DRAGOUT:Function 
    135         private static var DEFAULT_ACTION_PRESS:Function  
    136         private static var DEFAULT_ACTION_RELEASE:Function  
    137         private static var DEFAULT_ACTION_RELEASEOUTSIDE:Function  
    138          
     122        private static var DEFAULT_ACTION_ROLLOVER:Function; 
     123        private static var DEFAULT_ACTION_ROLLOUT:Function; 
     124        private static var DEFAULT_ACTION_DRAGOUT:Function; 
     125        private static var DEFAULT_ACTION_PRESS:Function; 
     126        private static var DEFAULT_ACTION_RELEASE:Function; 
     127        private static var DEFAULT_ACTION_RELEASEOUTSIDE:Function; 
    139128        /*-------------------- 
    140129         インスタンス毎のパラメータ 
     
    142131        //ヒットエリア用表示オブジェクト 
    143132        private var hitAreaBase:MovieClip; 
    144          
    145133        //ボタンが配置されている場所の参照 
    146         private var buttonRoot:MovieClip 
    147          
     134        private var buttonRoot:MovieClip; 
    148135        //所属グループ名 
    149136        public var group:String; 
    150          
    151          
    152137        /*-------------------- 
    153138         コンストラクタ 
    154139        --------------------*/ 
    155         public function ButtonGroupManager( tgt:MovieClip, tgtGroupName:String ,isCopyDefaults:Boolean) 
    156         { 
    157                  
     140        public function ButtonGroupManager(tgt:MovieClip, tgtGroupName:String, isCopyDefaults:Boolean) 
     141        { 
    158142                trace("ボタンを設定:ButtonGroupManager()"); 
    159  
    160143                //初めて実行された場合だけクラスの初期値を設定する 
    161                 if (firstRun == true) { 
    162                         
     144                if (firstRun == true) 
     145                { 
    163146                        trace(" *クラス全体の初期化を実行"); 
    164147                        //グループ管理用配列を初期化し、デフォルトグループを作る 
    165148                        groups = new Array(); 
    166149                        groups[DEFAULT_GROUP_NAME] = new Array(); 
    167                          
    168150                        //デフォルトのエフェクトを設定 
    169                         DEFAULT_ACTION_ROLLOVER = function ():Void { 
    170                         TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{brightness:0.3}, ease:Linear.easeNone}) 
    171                         }
    172                          
    173                         DEFAULT_ACTION_ROLLOUT = function ():Void { 
    174                                TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{}, ease:Linear.easeNone}) 
    175                         }
    176                          
    177                         DEFAULT_ACTION_DRAGOUT = function ():Void { 
    178                                TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{}, ease:Linear.easeNone}) 
    179                         }
    180                          
    181                         DEFAULT_ACTION_PRESS = function ():Void { 
    182                                TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{brightness:0}, ease:Linear.easeNone}) 
    183                         }
    184                          
    185                         DEFAULT_ACTION_RELEASE = function ():Void { 
    186                                TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{}, ease:Linear.easeNone}) 
    187                         }
    188                          
    189                         DEFAULT_ACTION_RELEASEOUTSIDE = function ():Void { 
    190                                TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{}, ease:Linear.easeNone}) 
    191                         }
    192                          
     151                        DEFAULT_ACTION_ROLLOVER = function ():Void 
     152                        { 
     153                               TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{brightness:0.3}, ease:Linear.easeNone})
     154                        }; 
     155                        DEFAULT_ACTION_ROLLOUT = function ():Void 
     156                        { 
     157                               TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{}, ease:Linear.easeNone})
     158                        }; 
     159                        DEFAULT_ACTION_DRAGOUT = function ():Void 
     160                        { 
     161                               TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{}, ease:Linear.easeNone})
     162                        }; 
     163                        DEFAULT_ACTION_PRESS = function ():Void 
     164                        { 
     165                               TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{brightness:0}, ease:Linear.easeNone})
     166                        }; 
     167                        DEFAULT_ACTION_RELEASE = function ():Void 
     168                        { 
     169                               TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{}, ease:Linear.easeNone})
     170                        }; 
     171                        DEFAULT_ACTION_RELEASEOUTSIDE = function ():Void 
     172                        { 
     173                               TweenMax.to(this, DEFAULT_DURATION, {colorMatrixFilter:{}, ease:Linear.easeNone})
     174                        }; 
    193175                        //デフォルト値を配列に直接格納 
    194                         groups.DEFAULT.rollOver = new Array( DEFAULT_ACTION_ROLLOVER ); 
    195                         groups.DEFAULT.rollOut = new Array( DEFAULT_ACTION_ROLLOUT ); 
    196                         groups.DEFAULT.dragOut = new Array( DEFAULT_ACTION_DRAGOUT ); 
    197                         groups.DEFAULT.press = new Array( DEFAULT_ACTION_PRESS ); 
    198                         groups.DEFAULT.release = new Array( DEFAULT_ACTION_RELEASE ); 
    199                         groups.DEFAULT.releaseOutside = new Array( DEFAULT_ACTION_RELEASEOUTSIDE ); 
    200  
     176                        groups.DEFAULT.rollOver = new Array(DEFAULT_ACTION_ROLLOVER); 
     177                        groups.DEFAULT.rollOut = new Array(DEFAULT_ACTION_ROLLOUT); 
     178                        groups.DEFAULT.dragOut = new Array(DEFAULT_ACTION_DRAGOUT); 
     179                        groups.DEFAULT.press = new Array(DEFAULT_ACTION_PRESS); 
     180                        groups.DEFAULT.release = new Array(DEFAULT_ACTION_RELEASE); 
     181                        groups.DEFAULT.releaseOutside = new Array(DEFAULT_ACTION_RELEASEOUTSIDE); 
    201182                        //全ボタンリスト初期化 
    202183                        buttonList = new Array(); 
    203                          
    204184                        //クラス初期化済みフラグON 
    205185                        firstRun = false; 
    206186                } 
    207                  
    208                 //引数tgtがない(ライブラリから設定された)場合は、thisをbuttonRootとする。 
    209                 if (tgt == undefined)  
    210                 { 
    211                         buttonRoot = this 
     187                //引数tgtがない(ライブラリから設定された)場合は、thisをbuttonRootとする。    
     188                if (tgt == undefined) 
     189                { 
     190                        buttonRoot = this; 
    212191                } 
    213192                else 
     
    215194                        buttonRoot = tgt; 
    216195                } 
    217                  
    218196                //インスタンス単位の関数を格納する入れ物actionsを初期化 
    219197                actions = new Array(); 
    220                 for (var i:Number = 0; i<ACTION_TYPE_NAMES.length ;i++) { 
     198                for (var i:Number = 0; i < ACTION_TYPE_NAMES.length; i++) 
     199                { 
    221200                        actions[ACTION_TYPE_NAMES[i]] = new Array(); 
    222201                } 
    223                  
    224202                //引数groupNameが無い場合 
    225                 if (tgtGroupName == undefined || tgtGroupName == null ) { 
     203                if (tgtGroupName == undefined || tgtGroupName == null) 
     204                { 
    226205                        /* 
    227206                        trace(" !グループ名未設定: "+DEFAULT_GROUP_NAME+" に設定します"); 
     
    229208                        */ 
    230209                        //デフォルト値をコピーする場合 
    231                         if (isCopyDefaults == true ) { 
    232                                 actions.rollOver.push( DEFAULT_ACTION_ROLLOVER ); 
    233                                 actions.rollOut.push( DEFAULT_ACTION_ROLLOUT ); 
    234                                 actions.dragOut.push( DEFAULT_ACTION_DRAGOUT ); 
    235                                 actions.press.push( DEFAULT_ACTION_PRESS ); 
    236                                 actions.release.push( DEFAULT_ACTION_RELEASE ); 
    237                                 actions.releaseOutside.push( DEFAULT_ACTION_RELEASEOUTSIDE ); 
    238                         } 
    239                 } 
    240                 else if (groups[tgtGroupName] == undefined)  
     210                        if (isCopyDefaults == true) 
     211                        { 
     212                                actions.rollOver.push(DEFAULT_ACTION_ROLLOVER); 
     213                                actions.rollOut.push(DEFAULT_ACTION_ROLLOUT); 
     214                                actions.dragOut.push(DEFAULT_ACTION_DRAGOUT); 
     215                                actions.press.push(DEFAULT_ACTION_PRESS); 
     216                                actions.release.push(DEFAULT_ACTION_RELEASE); 
     217                                actions.releaseOutside.push(DEFAULT_ACTION_RELEASEOUTSIDE); 
     218                        } 
     219                } 
     220                else if (groups[tgtGroupName] == undefined) 
    241221                { 
    242222                        //tgtGroupNameグループが存在しなかったら作る 
    243                         addGroup(tgtGroupName ,isCopyDefaults); 
    244                 } 
    245  
     223                        addGroup(tgtGroupName, isCopyDefaults); 
     224                } 
    246225                group = tgtGroupName; 
    247                  
    248                 trace("ボタンターゲット:tgt:"+tgt+" groupName:"+group); 
    249  
     226                trace("ボタンターゲット:tgt:" + tgt + " groupName:" + group); 
    250227                //hitAreaBaseを設定 
    251228                hitAreaBase = buttonRoot.hitAreaBase; 
    252                  
    253229                //hitAreaBaseが見つからなかったら現在の大きさと同じ矩形を作って設定する 
    254230                if (buttonRoot.hitAreaBase == undefined) 
     
    264240                        hitAreaBase.endFill(); 
    265241                } 
    266                  
    267                 //hitAreaBaseをボタンのヒットエリアとする 
     242                //hitAreaBaseをボタンのヒットエリアとする    
    268243                buttonRoot.hitArea = hitAreaBase; 
    269                  
    270244                //ボタン有効 
    271245                setEnable(true); 
    272                  
    273246                //ボタンリストに追加 
    274247                buttonList.push(this); 
    275248        } 
    276  
    277  
    278249        /*-------------------- 
    279250         グループの追加 
    280251        --------------------*/ 
    281         public static function addGroup ( groupName:String ,isCopyDefaults:Boolean ):Void 
    282         { 
    283                 trace("グループの追加:ButtonGroupManager.addGroup() groupName:"+groupName ); 
    284  
     252        public static function addGroup(groupName:String, isCopyDefaults:Boolean):Void 
     253        { 
     254                trace("グループの追加:ButtonGroupManager.addGroup() groupName:" + groupName); 
    285255                //指定グループすでに存在していれば 
    286                 if (groups[groupName]  != undefined ) { 
     256                if (groups[groupName] != undefined) 
     257                { 
    287258                        trace(" !エラー!指定されたグループ名はすでに存在します。"); 
    288                         return ; 
    289                 } 
    290                  
    291                 //存在してなければ作成 
     259                        return; 
     260                } 
     261                //存在してなければ作成    
    292262                groups[groupName] = new Array(); 
    293  
    294263                //指定したグループ、アクションタイプの格納場所を初期化 
    295                 if (isCopyDefaults == true) { 
     264                if (isCopyDefaults == true) 
     265                { 
    296266                        //デフォルト値をコピーする場合 
    297                         groups[groupName].rollOver = new Array( DEFAULT_ACTION_ROLLOVER ); 
    298                         groups[groupName].rollOut = new Array( DEFAULT_ACTION_ROLLOUT ); 
    299                         groups[groupName].dragOut = new Array( DEFAULT_ACTION_DRAGOUT ); 
    300                         groups[groupName].press = new Array( DEFAULT_ACTION_PRESS ); 
    301                         groups[groupName].release = new Array( DEFAULT_ACTION_RELEASE ); 
    302                         groups[groupName].releaseOutside = new Array( DEFAULT_ACTION_RELEASEOUTSIDE ); 
     267                        groups[groupName].rollOver = new Array(DEFAULT_ACTION_ROLLOVER); 
     268                        groups[groupName].rollOut = new Array(DEFAULT_ACTION_ROLLOUT); 
     269                        groups[groupName].dragOut = new Array(DEFAULT_ACTION_DRAGOUT); 
     270                        groups[groupName].press = new Array(DEFAULT_ACTION_PRESS); 
     271                        groups[groupName].release = new Array(DEFAULT_ACTION_RELEASE); 
     272                        groups[groupName].releaseOutside = new Array(DEFAULT_ACTION_RELEASEOUTSIDE); 
    303273                } 
    304274                else 
     
    312282                } 
    313283        } 
    314          
    315284        /*-------------------- 
    316285         グループの削除 
    317286        --------------------*/ 
    318         public static function removeGroup ( groupName:String ):Void 
    319         { 
    320                 trace("グループの削除:ButtonGroupManager.removeGroup() groupName:"+groupName ); 
     287        public static function removeGroup(groupName:String):Void 
     288        { 
     289                trace("グループの削除:ButtonGroupManager.removeGroup() groupName:" + groupName); 
    321290                //デフォルトグループは削除させない。 
    322                 if (groupName == DEFAULT_GROUP_NAME) { 
    323                         trace(" !エラー!デフォルトグループ "+DEFAULT_GROUP_NAME+" は削除できません") 
    324                 } 
    325  
    326                 //指定グループが見つかったら削除 
    327                 for (var index:String in groups ) { 
    328                         if (index == groupName) { 
     291                if (groupName == DEFAULT_GROUP_NAME) 
     292                { 
     293                        trace(" !エラー!デフォルトグループ " + DEFAULT_GROUP_NAME + " は削除できません"); 
     294                } 
     295                //指定グループが見つかったら削除    
     296                for (var index in groups) 
     297                { 
     298                        if (index == groupName) 
     299                        { 
    329300                                //delete (groups[groupName]); 
    330301                                groups[groupName] = undefined; 
    331                                 trace(" "+groupName+"の削除に成功しました。"); 
     302                                trace(" " + groupName + "の削除に成功しました。"); 
    332303                                return; 
    333304                        } 
    334305                } 
    335                  
    336306                //見つからなかった 
    337                 trace(" "+groupName+" は見つかりませんでした。"); 
    338         } 
    339  
     307                trace(" " + groupName + " は見つかりませんでした。"); 
     308        } 
    340309        /*-------------------- 
    341310         アクションの追加 
    342311        --------------------*/ 
    343         public static function addAction ( type:String ,actionName:String, action:Function, groupName:String):String 
    344         { 
    345                 trace("アクションの追加:ButtonGroupManager.addAction() groupName:"+groupName+", type:"+type); 
    346                  
     312        public static function addAction(type:String, actionName:String, action:Function, groupName:String):String 
     313        { 
     314                trace("アクションの追加:ButtonGroupManager.addAction() groupName:" + groupName + ", type:" + type); 
    347315                //指定グループがなければ終了 
    348                 if (groups[groupName] == undefined ) { 
     316                if (groups[groupName] == undefined) 
     317                { 
    349318                        trace(" !エラー!指定されたグループ名は存在しません。"); 
    350                         return ; 
    351                 } 
    352  
     319                        return; 
     320                } 
     321                //アクションタイプ名チェック    
     322                var chkFlg:Boolean = false; 
     323                for (var i:Number = 0; i < ACTION_TYPE_NAMES.length; i++) 
     324                { 
     325                        if (ACTION_TYPE_NAMES[i] != type) 
     326                        { 
     327                                chkFlg = true; 
     328                        } 
     329                } 
     330                if (chkFlg != true) 
     331                { 
     332                        trace(" !エラー!アクションタイプ名が不正です。"); 
     333                        return; 
     334                } 
     335                //指定したグループ、アクションタイプの関数群に受け取った関数を追加    
     336                if (actionName == undefined || actionName == null || actionName == "") 
     337                { 
     338                        //関数名未設定の場合適当に名前を付ける 
     339                        actionName = "action_" + type + "_" + (++counter); 
     340                } 
     341                //関数名をプロパティ_nameに追加    
     342                action._name = actionName; 
     343                for (var i:Number = 0; i < groups[groupName][type].length; i++) 
     344                { 
     345                        if (action._name == groups[groupName][type][i]._name) 
     346                        { 
     347                                trace(" !エラー!アクション名が重複した為古いアクションは削除されます"); 
     348                                groups[groupName][type][i] = undefined; 
     349                        } 
     350                } 
     351                groups[groupName][type].push(action); 
     352                //登録した関数名を返す 
     353                return (actionName); 
     354        } 
     355        /*-------------------- 
     356         アクションの削除 
     357        --------------------*/ 
     358        public static function removeAction(type:String, actionName:String, groupName:String):Boolean 
     359        { 
     360                trace("アクションの削除:ButtonGroupManager.removeAction() groupName:" + groupName + ", type:" + type + ", actionName:" + actionName); 
     361                for (var i:Number = 0; i < groups[groupName][type].length; i++) 
     362                { 
     363                        if (groups[groupName][type][i]._name == actionName) 
     364                        { 
     365                                trace(" アクション " + actionName + " が見つかりました。削除します。"); 
     366                                groups[groupName][type].splice(i, 1); 
     367                                return true; 
     368                        } 
     369                } 
     370                return false; 
     371        } 
     372        /*-------------------- 
     373         アクションの追加(インスタンス単位) 
     374        --------------------*/ 
     375        public function addInstanceAction(type:String, actionName:String, action:Function):String 
     376        { 
     377                trace("アクションの追加(インスタンス単位):addInstanceAction() type:" + type + ", actionName:" + actionName); 
    353378                //アクションタイプ名チェック 
    354379                var chkFlg:Boolean = false; 
    355                 for (var i:Number = 0; i<ACTION_TYPE_NAMES.length ;i++) { 
    356                         if (ACTION_TYPE_NAMES[i] != type) { 
    357                                 chkFlg = true 
    358                         } 
    359                 } 
    360                 if (chkFlg != true ) { 
     380                for (var i:Number = 0; i < ACTION_TYPE_NAMES.length; i++) 
     381                { 
     382                        if (ACTION_TYPE_NAMES[i] != type) 
     383                        { 
     384                                chkFlg = true; 
     385                        } 
     386                } 
     387                if (chkFlg != true) 
     388                { 
    361389                        trace(" !エラー!アクションタイプ名が不正です。"); 
    362390                        return; 
    363391                } 
    364  
    365                  
    366                 //指定したグループ、アクションタイプの関数群に受け取った関数を追加 
    367                 if (actionName == undefined || actionName == null || actionName == "") { 
     392                //指定したグループ、アクションタイプの関数群に受け取った関数を追加    
     393                if (actionName == undefined || actionName == null || actionName == "") 
     394                { 
    368395                        //関数名未設定の場合適当に名前を付ける 
    369                         actionName = "action_"+type+"_"+(++counter); 
    370                          
    371                 } 
    372                  
    373                 //関数名をプロパティ_nameに追加 
     396                        actionName = "action_" + type + "_" + (++counter); 
     397                } 
     398                //関数名をプロパティ_nameに追加    
    374399                action._name = actionName; 
    375                 groups[groupName][type].push(action); 
    376  
     400                for (var i:Number = 0; i < actions[type].length; i++) 
     401                { 
     402                        if (action._name == actions[type][i]._name) 
     403                        { 
     404                                trace(" !エラー!アクション名が重複した為古いアクションは削除されます"); 
     405                                actions[type][i] = undefined; 
     406                        } 
     407                } 
     408                actions[type].push(action); 
    377409                //登録した関数名を返す 
    378410                return (actionName); 
    379  
    380         } 
    381          
    382         /*-------------------- 
    383          アクションの削除 
    384         --------------------*/ 
    385         public static function removeAction ( type:String, actionName:String, groupName:String):Boolean 
    386         { 
    387                 trace("アクションの削除:ButtonGroupManager.removeAction() groupName:"+groupName+", type:"+type+", actionName:"+actionName); 
    388                  
    389                 for (var i:Number = 0;i<groups[groupName][type].length;i++) { 
    390                         if (groups[groupName][type][i]._name == actionName)
    391                                 trace(" アクション "+actionName+" が見つかりました。削除します。"); 
    392                                 groups[groupName][type].splice(i,1); 
     411        } 
     412        /*-------------------- 
     413         アクションの削除(インスタンス単位 
     414        --------------------*/ 
     415        public function removeInstanceAction(type:String, actionName:String):Boolean 
     416        { 
     417               trace("アクションの削除(インスタンス単位:removeInstanceAction() type:" + type + ", actionName:" + actionName); 
     418               for (var i:Number = 0; i < actions[type].length; i++) 
     419                { 
     420                       trace(actions[type][i]._name); 
     421                       if (actions[type][i]._name == actionName) 
     422                       
     423                                trace(" アクション " + actionName + " が見つかりました。削除します。"); 
     424                                actions[type].splice(i, 1); 
    393425                                return true; 
    394426                        } 
     
    396428                return false; 
    397429        } 
    398          
    399         /*-------------------- 
    400          アクションの追加(インスタンス単位) 
    401         --------------------*/ 
    402         public function addInstanceAction ( type:String ,actionName:String, action:Function ):String 
    403         { 
    404                 trace("アクションの追加(インスタンス単位):addInstanceAction() type:"+type+", actionName:"+actionName); 
    405                  
    406  
    407                 //アクションタイプ名チェック 
    408                 var chkFlg:Boolean = false; 
    409                 for (var i:Number = 0; i<ACTION_TYPE_NAMES.length ;i++) { 
    410                         if (ACTION_TYPE_NAMES[i] != type) { 
    411                                 chkFlg = true 
    412                         } 
    413                 } 
    414                 if (chkFlg != true ) { 
    415                         trace(" !エラー!アクションタイプ名が不正です。"); 
    416                         return; 
    417                 } 
    418  
    419                  
    420                 //指定したグループ、アクションタイプの関数群に受け取った関数を追加 
    421                 if (actionName == undefined || actionName == null || actionName == "") { 
    422                         //関数名未設定の場合適当に名前を付ける 
    423                         actionName = "action_"+type+"_"+(++counter); 
    424                          
    425                 } 
    426                  
    427                 //関数名をプロパティ_nameに追加 
    428                 action._name = actionName; 
    429                 actions[type].push(action); 
    430                  
    431                 //登録した関数名を返す 
    432                 return (actionName); 
    433  
    434         } 
    435          
    436         /*-------------------- 
    437          アクションの削除(インスタンス単位 
    438         --------------------*/ 
    439         public function removeInstanceAction ( type:String, actionName:String ):Boolean 
    440         { 
    441                 trace("アクションの削除(インスタンス単位:removeInstanceAction() type:"+type+", actionName:"+actionName); 
    442                  
    443                 for (var i:Number = 0;i<actions[type].length;i++) { 
    444                         trace(actions[type][i]._name) 
    445                         if (actions[type][i]._name == actionName) { 
    446                                 trace(" アクション "+actionName+" が見つかりました。削除します。"); 
    447                                 actions[type].splice(i,1); 
    448                                 return true; 
    449                         } 
    450                 } 
    451                 return false; 
    452         }        
    453          
    454430        /*-------------------- 
    455431         ボタン有効・無効切り替え(インスタンス単位) 
    456432        --------------------*/ 
    457         public function setEnable (sw:Boolean):Void 
    458         { 
    459                 if (sw == true) { 
    460                         trace("ボタン有効無効:ButtonGroupManager.setEnable() ボタン"+ buttonRoot._name + "を有効にしました"); 
     433        public function setEnable(sw:Boolean):Void 
     434        { 
     435                if (sw == true) 
     436                { 
     437                        trace("ボタン有効:ButtonGroupManager.setEnable() ボタン" + buttonRoot._name + "を有効にしました"); 
    461438                } 
    462439                else 
    463440                { 
    464                         trace("ボタン有効無効:ButtonGroupManager.setEnable() ボタン"+ buttonRoot._name + "を無効にしました"); 
    465                 } 
    466  
     441                        trace("ボタン無効:ButtonGroupManager.setEnable() ボタン" + buttonRoot._name + "を無効にしました"); 
     442                } 
    467443                //ボタンイベント内からクラスを参照する為に 
    468                 var thisMC:MovieClip = this 
    469  
     444                var thisMC:MovieClip = this; 
    470445                //ボタン有効化 
    471                 if (sw == true)  
     446                if (sw == true) 
    472447                { 
    473448                        /*-------------------- 
    474449                         onRollOver 
    475450                        --------------------*/ 
    476                         buttonRoot.onRollOver = function  ()  
     451                        buttonRoot.onRollOver = function() 
    477452                        { 
    478453                                //対象グループを探す。無所属やグループが存在しない場合はインスタンスの関数群を参照 
    479454                                var tgtElm:Array; 
    480                                 if (typeof thisMC.group != "string" || groups[thisMC.group] == undefined)  
    481                                 { 
    482                                                tgtElm = thisMC.actions; 
     455                                if (typeof thisMC.group != "string" || groups[thisMC.group] == undefined) 
     456                                { 
     457                                        tgtElm = thisMC.actions; 
    483458                                } 
    484459                                else 
    485460                                { 
    486                                                 tgtElm = groups[thisMC.group] 
    487                                 } 
    488                                  
     461                                        tgtElm = groups[thisMC.group]; 
     462                                } 
    489463                                //実処理 
    490                                 var tmpMethod:Function = this.onRollOver 
    491                                 for (var i:Number = 0; i<tgtElm.rollOver.length; i++  ) { 
     464                                var tmpMethod:Function = this.onRollOver; 
     465                                for (var i:Number = 0; i < tgtElm.rollOver.length; i++) 
     466                                { 
    492467                                        this.onRollOver = tgtElm.rollOver[i]; 
    493468                                        this.onRollOver(); 
     
    495470                                this.onRollOver = tmpMethod; 
    496471                        }; 
    497                          
    498472                        /*-------------------- 
    499473                         onRollOut 
    500474                        --------------------*/ 
    501                         buttonRoot.onRollOut = function  ()  
     475                        buttonRoot.onRollOut = function() 
    502476                        { 
    503477                                //対象グループを探す。無所属やグループが存在しない場合はインスタンスの関数群を参照 
    504478                                var tgtElm:Array; 
    505                                 if (thisMC.group == undefined || groups[thisMC.group] == undefined)  
    506                                 { 
    507                                                tgtElm = thisMC.actions; 
     479                                if (thisMC.group == undefined || groups[thisMC.group] == undefined) 
     480                                { 
     481                                        tgtElm = thisMC.actions; 
    508482                                } 
    509483                                else 
    510484                                { 
    511                                                tgtElm = groups[thisMC.group] 
     485                                        tgtElm = groups[thisMC.group]; 
    512486                                } 
    513487                                //実処理                            
    514                                 var tmpMethod:Function = this.onRollOut 
    515                                 for (var i:Number = 0; i<tgtElm.rollOut.length; i++  ) { 
     488                                var tmpMethod:Function = this.onRollOut; 
     489                                for (var i:Number = 0; i < tgtElm.rollOut.length; i++) 
     490                                { 
    516491                                        this.onRollOut = tgtElm.rollOut[i]; 
    517492                                        this.onRollOut(); 
    518493                                } 
    519                                 this.onRollOut = tmpMethod;      
    520                         }; 
    521  
     494                                this.onRollOut = tmpMethod; 
     495                        }; 
    522496                        /*-------------------- 
    523497                         onDragOut 
    524498                        --------------------*/ 
    525                         buttonRoot.onDragOut = function  ()  
     499                        buttonRoot.onDragOut = function() 
    526500                        { 
    527501                                //対象グループを探す。無所属やグループが存在しない場合はインスタンスの関数群を参照 
    528502                                var tgtElm:Array; 
    529                                 if (thisMC.group == undefined || groups[thisMC.group] == undefined)  
    530                                 { 
    531                                                tgtElm = thisMC.actions; 
     503                                if (thisMC.group == undefined || groups[thisMC.group] == undefined) 
     504                                { 
     505                                        tgtElm = thisMC.actions; 
    532506                                } 
    533507                                else 
    534508                                { 
    535                                                tgtElm = groups[thisMC.group] 
     509                                        tgtElm = groups[thisMC.group]; 
    536510                                } 
    537511                                //実処理                            
    538                                 var tmpMethod:Function = this.onDragOut 
    539                                 for (var i:Number = 0; i<tgtElm.dragOut.length; i++  ) { 
     512                                var tmpMethod:Function = this.onDragOut; 
     513                                for (var i:Number = 0; i < tgtElm.dragOut.length; i++) 
     514                                { 
    540515                                        this.onDragOut = tgtElm.dragOut[i]; 
    541516                                        this.onDragOut(); 
     
    543518                                this.onDragOut = tmpMethod; 
    544519                        }; 
    545  
    546                          
    547520                        /*-------------------- 
    548521                         onPress 
    549522                        --------------------*/ 
    550                         buttonRoot.onPress = function  ()  
     523                        buttonRoot.onPress = function() 
    551524                        { 
    552525                                //対象グループを探す。無所属やグループが存在しない場合はインスタンスの関数群を参照 
    553526                                var tgtElm:Array; 
    554                                 if (thisMC.group == undefined || groups[thisMC.group] == undefined)  
    555                                 { 
    556                                                tgtElm = thisMC.actions; 
     527                                if (thisMC.group == undefined || groups[thisMC.group] == undefined) 
     528                                { 
     529                                        tgtElm = thisMC.actions; 
    557530                                } 
    558531                                else 
    559532                                { 
    560                                                tgtElm = groups[thisMC.group] 
     533                                        tgtElm = groups[thisMC.group]; 
    561534                                } 
    562535                                //実処理                            
    563                                 var tmpMethod:Function = this.onPress 
    564                                 for (var i:Number = 0; i<tgtElm.press.length; i++  ) { 
     536                                var tmpMethod:Function = this.onPress; 
     537                                for (var i:Number = 0; i < tgtElm.press.length; i++) 
     538                                { 
    565539                                        this.onPress = tgtElm.press[i]; 
    566540                                        this.onPress(); 
    567541                                } 
    568                                 this.onPress = tmpMethod;                                
    569                         }; 
    570                          
     542                                this.onPress = tmpMethod; 
     543                        }; 
    571544                        /*-------------------- 
    572545                         onRelease 
    573546                        --------------------*/ 
    574                         buttonRoot.onRelease = function  () 
     547                        buttonRoot.onRelease = function() 
    575548                        { 
    576549                                //対象グループを探す。無所属やグループが存在しない場合はインスタンスの関数群を参照 
    577550                                var tgtElm:Array; 
    578                                 if (thisMC.group == undefined || groups[thisMC.group] == undefined)  
    579                                 { 
    580                                                tgtElm = thisMC.actions; 
     551                                if (thisMC.group == undefined || groups[thisMC.group] == undefined) 
     552                                { 
     553                                        tgtElm = thisMC.actions; 
    581554                                } 
    582555                                else 
    583556                                { 
    584                                                tgtElm = groups[thisMC.group] 
     557                                        tgtElm = groups[thisMC.group]; 
    585558                                } 
    586559                                //実処理                            
    587                                 var tmpMethod:Function = this.onRelease 
    588                                 for (var i:Number = 0; i<tgtElm.release.length; i++  ) { 
     560                                var tmpMethod:Function = this.onRelease; 
     561                                for (var i:Number = 0; i < tgtElm.release.length; i++) 
     562                                { 
    589563                                        this.onRelease = tgtElm.release[i]; 
    590564                                        this.onRelease(); 
    591565                                } 
    592                                 this.onRelease = tmpMethod;                              
    593                         } 
    594                          
     566                                this.onRelease = tmpMethod; 
     567                        }; 
    595568                        /*-------------------- 
    596569                         onReleaseOutside 
    597570                        --------------------*/ 
    598                         buttonRoot.onReleaseOutside = function  () 
     571                        buttonRoot.onReleaseOutside = function() 
    599572                        { 
    600573                                //対象グループを探す。無所属やグループが存在しない場合はインスタンスの関数群を参照 
    601574                                var tgtElm:Array; 
    602                                 if (thisMC.group == undefined || groups[thisMC.group] == undefined)  
    603                                 { 
    604                                                tgtElm = thisMC.actions; 
     575                                if (thisMC.group == undefined || groups[thisMC.group] == undefined) 
     576                                { 
     577                                        tgtElm = thisMC.actions; 
    605578                                } 
    606579                                else 
    607580                                { 
    608                                                tgtElm = groups[thisMC.group] 
     581                                        tgtElm = groups[thisMC.group]; 
    609582                                } 
    610583                                //実処理                            
    611                                 var tmpMethod:Function = this.onReleaseOutside 
    612                                 for (var i:Number = 0; i<tgtElm.releaseOutside.length; i++  ) { 
     584                                var tmpMethod:Function = this.onReleaseOutside; 
     585                                for (var i:Number = 0; i < tgtElm.releaseOutside.length; i++) 
     586                                { 
    613587                                        this.onReleaseOutside = tgtElm.releaseOutside[i]; 
    614588                                        this.onReleaseOutside(); 
    615589                                } 
    616                                 this.onReleaseOutside = tmpMethod;              
    617                         }       
     590                                this.onReleaseOutside = tmpMethod; 
     591                        }; 
    618592                } 
    619593                else 
     
    625599                        delete buttonRoot.onPress; 
    626600                        delete buttonRoot.onRelease; 
    627                          
    628                 } 
    629         } 
    630          
     601                } 
     602        } 
    631603        /*-------------------- 
    632604         ボタンリストを取得 
    633605        --------------------*/ 
    634         public static function getButtonList ():Array { 
     606        public static function getButtonList():Array 
     607        { 
    635608                trace("登録済みボタンリストの取得:ButtonGroupManager.getButtonList()"); 
    636609                var tmpArray:Array = new Array(); 
    637                 while (buttonList.length>0) { 
     610                while (buttonList.length > 0) 
     611                { 
    638612                        var tmpElm:Object = buttonList.shift(); 
    639                         if (tmpElm != undefined) { 
     613                        if (tmpElm != undefined) 
     614                        { 
    640615                                tmpArray.push(tmpElm); 
    641616                        } 
    642  
    643617                } 
    644618                buttonList = tmpArray.slice(); 
    645                 trace(" 長さ:"+buttonList.length); 
     619                trace(" 長さ:" + buttonList.length); 
    646620                return (buttonList); 
    647621        } 
    648  
    649  
    650622}