0.6.x/js/core/06_XEventDispatcher.js

   1 /**\r
   2  * use X.Callback\r
   3  */\r
   4 \r
   5 X.Event = {\r
   6         COMPLETE    : 1,\r
   7         SUCCESS     : 2,\r
   8         ERROR       : 3,\r
   9         PROGRESS    : 4,\r
  10         _LAST_EVENT : 4\r
  11 };\r
  12 \r
  13 \r
  14 X.EventDispatcher =\r
  15         X.Class.create(\r
  16                 'EventDispatcher',\r
  17                 {\r
  18                         _listeners    : null,\r
  19                         _dispatching  : 0, // dispatch 中の unlisten で使用\r
  20                         _unlistens    : null, // dispatch 中の unlisten で使用\r
  21                         _needsIndex   : false, // listening で index を返す\r
  22                         _reserves     : null,\r
  23                         _killReserved : false,\r
  24                         \r
  25                         listen : function( type, arg1, arg2, arg3 ){\r
  26                                 var list = this._listeners,\r
  27                                         r, f;\r
  28                                 if( this._dispatching ){\r
  29                                         // todo\r
  30                                         // reserve\r
  31                                         if( !this._reserves ) this._reserves = [];\r
  32                                         this._reserves[ this._reserves.length ] = [ type, arg1, arg2, arg3 ];\r
  33                                         return this;\r
  34                                 } else\r
  35                                 if( this.listening( type, arg1, arg2, arg3 ) ) return this;\r
  36 \r
  37                                 if( !list ) list = this._listeners = {};\r
  38                                 if( !( list = list[ type ] ) ) list = this._listeners[ type ] = [];\r
  39                                 list[ list.length ] = f =\r
  40                                         ( arg1 && !arg2 ) ?\r
  41                                                 arg1 :\r
  42                                                 X.Callback.create( arg1, arg2, arg3 );\r
  43                                 f.once = X.EventDispatcher._once;\r
  44                                 return this;\r
  45                         },\r
  46                         listenOnce : function( type, arg1, arg2, arg3 ){\r
  47                                 X.EventDispatcher._once = true;\r
  48                                 this.listen( type, arg1, arg2, arg3 );\r
  49                                 X.EventDispatcher._once = false;\r
  50                                 return this;\r
  51                         },\r
  52                         unlisten : function( type, arg1, arg2, arg3 ){\r
  53                                 var list = this._listeners,\r
  54                                         _list, reserves, unlistens, i, f;\r
  55                                 if( !list ) return this;\r
  56                                 if( type === undefined ){\r
  57                                         // 全て削除\r
  58                                         for( type in list ){\r
  59                                                 _list = list[ type ];\r
  60                                                 if( !( i = _list.length ) ) continue;\r
  61                                                 for( ; i; ){\r
  62                                                         this.unlisten( type, _list[ --i ] ); // override されていることがあるので、必ず unlisten を使用\r
  63                                                 };\r
  64                                                 // this.unlisten( type ); これは無茶！\r
  65                                         };\r
  66                                         return this;\r
  67                                 };\r
  68                                 if( arg1 === undefined ){\r
  69                                         // 同一タイプを全て削除\r
  70                                         if( !( list = list[ type ] ) || !( i = list.length ) ) return this;\r
  71                                         for( ; i; ){\r
  72                                                 this.unlisten( type, list[ --i ] ); // override されていることがあるので、必ず unlisten を使用\r
  73                                         };\r
  74                                         return this;\r
  75                                 };\r
  76                                 \r
  77                                 if( reserves = this._reserves ){\r
  78                                         for( i = reserves.length; i; ){\r
  79                                                 f = reserves[ --i ];\r
  80                                                 if( f[ 0 ] === type && f[ 1 ] === arg1 && f[ 2 ] === arg2 && f[ 3 ] === arg3 ){\r
  81                                                         reserves.splice( i, 1 );\r
  82                                                         if( !reserves.legth ) delete this._reserves;\r
  83                                                         return this;\r
  84                                                 };\r
  85                                         };\r
  86                                 };\r
  87                                 \r
  88                                 this._needsIndex = true;\r
  89                                 i = this.listening( type, arg1, arg2, arg3 );\r
  90                                 delete this._needsIndex;\r
  91                                 if( i === false ) return this;\r
  92 \r
  93                                 f = ( list = list[ type ] )[ i ];\r
  94                                 if( unlistens = this._unlistens ){\r
  95                                         ( unlistens = unlistens[ type ] ) ?\r
  96                                                 ( unlistens[ unlistens.length ] = f ) :\r
  97                                                 ( this._unlistens[ type ] = [ f ] );\r
  98                                 } else {\r
  99                                         delete f.once;\r
 100                                         f.kill === X.Callback._kill && f.kill();\r
 101                                         list.splice( i, 1 );\r
 102                                         if( !list.length ){\r
 103                                                 delete this._listeners[ type ];\r
 104                                                 if( X.isEmptyObject( this._listeners ) ) delete this._listeners;\r
 105                                         };\r
 106                                 };\r
 107                                 return this;\r
 108                         },\r
 109                         listening : function( type, arg1, arg2, arg3 ){\r
 110                                 var list = this._listeners, unlistens, i, f;\r
 111                                 if( type === undefined ) return !!list;\r
 112                                 if( !list || !( list = list[ type ] ) ) return false;\r
 113                                 if( arg1 === undefined ) return true;\r
 114                                 if( ( unlistens = this._unlistens ) && ( unlistens = unlistens[ type ] ) ){\r
 115                                         for( i = unlistens.length; i; ){\r
 116                                                 f = unlistens[ --i ];\r
 117                                                 if( f === arg1 || ( f.same && f.same( arg1, arg2, arg3 ) ) ) return false;\r
 118                                         };\r
 119                                 };\r
 120                                 for( i = list.length; i; ){\r
 121                                         f = list[ --i ];\r
 122                                         if( f === arg1 || ( f.same && f.same( arg1, arg2, arg3 ) ) ) return this._needsIndex ? i : true;\r
 123                                 };\r
 124                                 return false;\r
 125                         },\r
 126                         /*\r
 127                          * dispatch 中に dispatch が呼ばれるケースがあるため、\r
 128                          * _dispatching では その深さを保存する\r
 129                          * _dispatching が 0 のときに unlistens を削除する\r
 130                          *\r
 131                          */\r
 132                         dispatch : function( e ){\r
 133                                 // dispatch 中の listen は？\r
 134                                 var list  = this._listeners,\r
 135                                         ret   = X.Callback.NONE,\r
 136                                         type  = e.type,\r
 137                                         unlistens, i, l, f, r, sysOnly;\r
 138 \r
 139                                 if( !list || !( list = list[ type ] ) ) return ret;\r
 140                                 \r
 141                                 ++this._dispatching;\r
 142                                 \r
 143                                 // todo:\r
 144                                 // type も保存\r
 145                                 this._unlistens = this._unlistens || {};\r
 146                                 unlistens = this._unlistens[ type ];\r
 147                                 \r
 148                                 for( i = 0; i < list.length; ++i ){\r
 149                                         f = list[ i ];\r
 150                                         if( unlistens && unlistens.indexOf( f ) !== -1 ) continue;\r
 151 \r
 152                                         r = typeof f === 'function' ? f( e ) : f.handleEvent( e );\r
 153                                         \r
 154                                         if( f.once === true || r & X.Callback.UN_LISTEN ){\r
 155                                                 unlistens ?\r
 156                                                         ( unlistens[ unlistens.length ] = f ) :\r
 157                                                         ( unlistens = this._unlistens[ type ] = [ f ] );\r
 158                                         };\r
 159 \r
 160                                         if( r & X.Callback.STOP_NOW ){\r
 161                                                 sysOnly = true;\r
 162                                         };\r
 163                                         ret |= r;\r
 164                                 };\r
 165                                 \r
 166                                 if( ( --this._dispatching ) === 0 ){\r
 167                                         // dispatch 中に unlisten された要素の削除\r
 168                                         unlistens = this._unlistens;\r
 169                                         delete this._dispatching;\r
 170                                         delete this._unlistens;                                 \r
 171                                         \r
 172                                         for( type in unlistens ){\r
 173                                                 list = unlistens[ type ];\r
 174                                                 for( i = list.length; i; ){\r
 175                                                         this.unlisten( type, list[ --i ] );\r
 176                                                 };\r
 177                                                 unlistens.length = 0;\r
 178                                         };\r
 179                                         \r
 180                                         if( this._killReserved ){\r
 181                                                 this.kill();\r
 182                                         } else\r
 183                                         if( list = this._reserves ){\r
 184                                                 for( i = 0, l = list.length; i < l; ++i ){\r
 185                                                         f = list[ i ];\r
 186                                                         this.listen( f[ 0 ], f[ 1 ], f[ 2 ], f[ 3 ] );\r
 187                                                         f.length = 0;\r
 188                                                 };\r
 189                                                 list.length = 0;\r
 190                                                 delete this._reserves;\r
 191                                         };\r
 192                                 };\r
 193                                 \r
 194                                 return ret;\r
 195                         },\r
 196                         \r
 197                         onKill : function(){\r
 198                                 if( this._dispatching ){\r
 199                                         this._killReserved = true;\r
 200                                         return false;\r
 201                                 };\r
 202                                 this._listeners && this.unlisten();\r
 203                         },\r
 204                         \r
 205                         asyncDispatch : function( delay, e ){\r
 206                                 return X.Timer.once( delay, this, this.dispatch, [ e ] );\r
 207                         }\r
 208                 }\r
 209         );\r
 210 \r
 211 X.EventDispatcher._once = false;\r