/*\r
* pettanR peta.common.js\r
- * version 0.5.39\r
+ * version 0.5.41\r
* \r
* author:\r
* itozyun\r
})(),\r
IS_DEBUG = Type.isBoolean( URL_PARAMS.debug ) ? URL_PARAMS.debug : IS_LOCAL === true;\r
return {\r
- version: '0.5.31',\r
+ version: '0.5.40',\r
URL_PARAMS: URL_PARAMS,\r
LOCAL: IS_LOCAL,\r
DEBUG: IS_DEBUG,\r
NAMESPACE_CLASSNAME = pettanr.CONST.NS_PETTANR_COMIC + '-',\r
PICTURE_PATH = pettanr.CONST.PANEL_PICTURE_PATH,\r
ELM_DETECT_WIDTH = ( function(){\r
- var ret = document.createElement( 'div');\r
+ var ret = document.createElement( 'div' );\r
ret.style.cssText = 'width: auto;height: 0;padding: 0;margin: 0;display: block;visibility: hidden;float: none;position: static;';\r
return ret;\r
})(),\r
};\r
\r
\r
- var ElementBuilderClass = function( elmTarget, noClassnameMode ){\r
- var RIMG_ARRAY = [],\r
- BALLOON_ARRAY = [];\r
- \r
- function buildComicElement(){\r
+ var ElementBuilder = function( elmTarget, noClassname ){\r
+ this.imageList = [];\r
+ this.balloonList = [];\r
+ this.elmTarget = elmTarget;\r
+ this.noClassname = noClassname;\r
+ };\r
+ ElementBuilder.prototype = {\r
+ build : function( json, zoom ){\r
+ this.clean();\r
\r
- };\r
- \r
- function buildPanelElement( json, zoom ){\r
- var _elmPanel = document.createElement( 'div' ),\r
- _style = {\r
+ // json is Comic ? Panel ?\r
+ var panels = json.children || json.stories,\r
+ i, l;\r
+ if( Type.isArray( panels ) === true ){\r
+ // comic\r
+ for( i = 0, l = panels.length; i<l; ++i ){\r
+ this.buildPanelElement( panels[ i ], zoom );\r
+ };\r
+ } else\r
+ if( json.elements ){\r
+ // panel\r
+ this.buildPanelElement( json, zoom );\r
+ } else {\r
+ // invalid json\r
+ };\r
+ },\r
+ buildComicElement : function(){\r
+ \r
+ },\r
+ buildPanelElement : function( json, zoom ){\r
+ var elmPanel = document.createElement( 'div' ),\r
+ style = {\r
'border-width': typeof json.border === 'number' ? json.border + 'px' : 0,\r
- width: json.width + 'px',\r
+ width: json.width + 'px',\r
height: json.height + 'px'\r
},\r
- _cssText = [],\r
- _comicElements = json.elements || ( json.panel ? json.panel.elements : [] ),\r
- _comicElement, _elmImg, _rImg, _rPic,\r
- _balloon, _elmBalloonWrap, _elmText, _text, _speechesAttributes, _key,\r
- i, l;\r
- elmTarget.appendChild( _elmPanel );\r
+ cssText = [],\r
+ elements = json.elements || ( json.panel ? json.panel.elements : [] ),\r
+ rPic,\r
+ p, i, l;\r
+ this.elmTarget.appendChild( elmPanel );\r
\r
- if( noClassnameMode === true ){\r
+ if( this.noClassname === true ){\r
\r
} else {\r
- _elmPanel.className = NAMESPACE_CLASSNAME + 'panel';\r
+ elmPanel.className = NAMESPACE_CLASSNAME + 'panel';\r
};\r
- for( _key in _style ){\r
- _cssText.push( _key + ':' + _style[ _key ] );\r
+ for( p in style ){\r
+ cssText.push( p + ':' + style[ p ] );\r
};\r
- _elmPanel.style.cssText = _cssText.join( ';' );\r
+ elmPanel.style.cssText = cssText.join( ';' );\r
\r
- for( i = 0, l = _comicElements.length; i<l; ++i ){\r
- _comicElement = _comicElements[ i ];\r
- _rPic = _comicElement.picture;\r
- if( _rPic ){\r
- _rImg = pettanr.image.createReversibleImage(\r
- [ PICTURE_PATH, _rPic.id, '.', _rPic.ext ].join( ''),\r
- _comicElement.width, _comicElement.height\r
- );\r
- _elmImg = _rImg.elm;\r
- _elmPanel.appendChild( _elmImg );\r
- _elmImg.className = NAMESPACE_CLASSNAME + 'image';\r
- _elmImg.style.cssText = [\r
- 'left:', _comicElement.x, 'px;',\r
- 'top:', _comicElement.y, 'px;',\r
- 'z-index:',_comicElement.z, ';'\r
- ].join( ''); \r
- if( _elmImg.tagName === 'img' ){\r
- _elmImg.width = Math.abs( _comicElement.width );\r
- _elmImg.height = Math.abs( _comicElement.height );\r
- } else {\r
- _elmImg.style.width = Math.abs( _comicElement.width ) + 'px';\r
- _elmImg.style.height = Math.abs( _comicElement.height ) + 'px';\r
- };\r
- \r
- RIMG_ARRAY.push( _rImg );\r
+ for( i = 0, l = elements.length; i < l; ++i ){\r
+ data = elements[ i ];\r
+ rPic = data.picture;\r
+ if( rPic ){\r
+ this.buildImage( elmPanel, data, rPic );\r
} else {\r
- _elmBalloonWrap = document.createElement( 'div' );\r
- _elmPanel.appendChild( _elmBalloonWrap );\r
- _elmBalloonWrap.className = NAMESPACE_CLASSNAME + 'balloon';\r
- _elmBalloonWrap.style.cssText = [\r
- 'width:', _comicElement.width, 'px;',\r
- 'height:', _comicElement.height, 'px;',\r
- 'left:', _comicElement.x, 'px;',\r
- 'top:', _comicElement.y, 'px;',\r
- 'z-index:', _comicElement.z, ';'\r
- ].join( '');\r
-\r
- _balloon = pettanr.balloon.createBalloon( _comicElement.width, _comicElement.height, _comicElement.tail );\r
- _elmBalloonWrap.appendChild( _balloon.elm );\r
- \r
- _elmText = document.createElement( 'p' );\r
- _elmBalloonWrap.appendChild( _elmText );\r
- \r
- _elmText.appendChild( document.createElement( 'span' ) );\r
- \r
- _text = '';\r
- _speechesAttributes = _comicElement.speeches_attributes;\r
- if( _speechesAttributes ){\r
- for( _key in _speechesAttributes ){\r
- _text += _speechesAttributes[ _key ] && _speechesAttributes[ _key ].content ? _speechesAttributes[ _key ].content : '';\r
- };\r
- };\r
- _elmText.firstChild.appendChild( document.createTextNode( _text ));\r
- BALLOON_ARRAY.push( _balloon );\r
+ this.buildBalloon( elmPanel, data );\r
};\r
};\r
- };\r
- \r
- function clean(){\r
- // clean elmTarget\r
- while( RIMG_ARRAY.length > 0 ){\r
- RIMG_ARRAY.shift().destroy();\r
- };\r
- while( BALLOON_ARRAY.length > 0 ){\r
- BALLOON_ARRAY.shift().destroy();\r
+ },\r
+ buildImage : function( elmPanel, data, rPic ){\r
+ var rImg = pettanr.image.createReversibleImage(\r
+ [ PICTURE_PATH, data.picture_id, '.', rPic.ext ].join( '' ),\r
+ data.width, data.height\r
+ ),\r
+ elmImg = rImg.elm;\r
+ elmPanel.appendChild( elmImg );\r
+ elmImg.className = NAMESPACE_CLASSNAME + 'image';\r
+ elmImg.style.cssText = [\r
+ 'left:', data.x, 'px;',\r
+ 'top:', data.y, 'px;',\r
+ 'z-index:', data.z, ';'\r
+ ].join( ''); \r
+ if( elmImg.tagName === 'img' ){\r
+ elmImg.width = Math.abs( data.width );\r
+ elmImg.height = Math.abs( data.height );\r
+ } else {\r
+ elmImg.style.width = Math.abs( data.width ) + 'px';\r
+ elmImg.style.height = Math.abs( data.height ) + 'px';\r
};\r
- Util.removeAllChildren( elmTarget ); \r
- };\r
- \r
- this.build = function( json, zoom ){\r
- clean();\r
\r
- // json is Comic ? Panel ?\r
- var stories = json.children || json.stories,\r
- i, l;\r
- if( Type.isArray( stories ) === true ){\r
- // comic\r
- for( i = 0, l = stories.length; i<l; ++i ){\r
- buildPanelElement( stories[ i ], zoom );\r
+ this.imageList.push( rImg ); \r
+ },\r
+ buildBalloon : function( elmPanel, data ){\r
+ var elmBalloonWrap = document.createElement( 'div' ),\r
+ elmText = document.createElement( 'p' ),\r
+ content = '',\r
+ speechesAttr = data.speeches_attributes,\r
+ balloon, p;\r
+ elmPanel.appendChild( elmBalloonWrap );\r
+ elmBalloonWrap.className = NAMESPACE_CLASSNAME + 'balloon';\r
+ elmBalloonWrap.style.cssText = [\r
+ 'width:', data.width, 'px;',\r
+ 'height:', data.height, 'px;',\r
+ 'left:', data.x, 'px;',\r
+ 'top:', data.y, 'px;',\r
+ 'z-index:', data.z, ';'\r
+ ].join( '' );\r
+\r
+ balloon = pettanr.balloon.createBalloon( data.width, data.height, data.tail );\r
+ elmBalloonWrap.appendChild( balloon.elm );\r
+ \r
+ elmBalloonWrap.appendChild( elmText );\r
+ \r
+ elmText.appendChild( document.createElement( 'span' ) );\r
+ \r
+ if( speechesAttr ){\r
+ for( p in speechesAttr ){\r
+ content += speechesAttr[ p ] && speechesAttr[ p ].content ? speechesAttr[ p ].content : '';\r
};\r
- } else\r
- if( json.elements ){\r
- // panel\r
- buildPanelElement( json, zoom );\r
- } else {\r
- // invalid json\r
};\r
- };\r
- this.zoom = function(){\r
- \r
- };\r
- this.destroy = function(){\r
- clean();\r
- };\r
+ elmText.firstChild.appendChild( document.createTextNode( content ));\r
+ this.balloonList.push( balloon );\r
+ },\r
+ clean : function(){\r
+ // clean elmTarget\r
+ while( this.imageList.length > 0 ){\r
+ this.imageList.shift().destroy();\r
+ };\r
+ while( this.balloonList.length > 0 ){\r
+ this.balloonList.shift().destroy();\r
+ };\r
+ Util.removeAllChildren( this.elmTarget );\r
+ },\r
+ zoom : function(){},\r
+ destroy : function(){\r
+ this.clean();\r
+ } \r
};\r
\r
- var BindWorkerClass = function( elmTarget, json, zoomSelfEnabled, noClassnameMode ){\r
- var builder = new ElementBuilderClass( elmTarget, noClassnameMode );\r
- var elmDetectW = ELM_DETECT_WIDTH.cloneNode( false );\r
- var resizer = null;\r
- \r
+ var BindWorker = function( elmTarget, json, zoomSelfEnabled, noClassname ){\r
+ this.builder = new ElementBuilder( elmTarget, noClassname );\r
+ this.elmDetectW = ELM_DETECT_WIDTH.cloneNode( false );\r
+ this._json = json;\r
+ this.noClassname = noClassname;\r
if( zoomSelfEnabled === true ){\r
- elmTarget.parentNode.insertBefore( elmDetectW, elmTarget );\r
- resizer = new ResizeAgentClass( onResize, elmDetectW );\r
+ elmTarget.parentNode.insertBefore( this.elmDetectW, elmTarget );\r
+ this.resizer = new ResizeAgentClass( onResize, this.elmDetectW );\r
};\r
function onResize(){\r
\r
};\r
- json && typeof json === 'object' && builder.build( json );\r
- \r
- this.init = function(){\r
+ json && typeof json === 'object' && this.builder.build( json );\r
+ };\r
+ BindWorker.prototype = {\r
+ init : function(){\r
\r
- };\r
- this.zoom = function(){\r
- builder.zoom();\r
- };\r
- this.json = function( _json ){\r
- json = _json;\r
- builder.build( _json );\r
- };\r
- this.targetElement = function(){\r
+ },\r
+ zoom : function(){\r
+ this.builder.zoom();\r
+ },\r
+ json : function( json ){\r
+ this._json = json;\r
+ this.builder.build( json, this.noClassname );\r
+ },\r
+ targetElement : function(){\r
\r
- };\r
- this.layout = function(){\r
+ },\r
+ layout : function(){\r
\r
- };\r
- this.destroy = function(){\r
- builder.destroy();\r
- elmTarget = json = builder = null;\r
- };\r
+ },\r
+ destroy : function(){\r
+ this.builder.destroy();\r
+ delete this.json;\r
+ delete this.builder;\r
+ } \r
};\r
- \r
return {\r
createBindWorker: function( elmTarget, opt_COMICJSONorPANELJSON, opt_zoomSelfEnabled, opt_noClassnameMode ){\r
- var ret = new BindWorkerClass( elmTarget, opt_COMICJSONorPANELJSON, !!opt_zoomSelfEnabled, !!opt_noClassnameMode);\r
+ var ret = new BindWorker( elmTarget, opt_COMICJSONorPANELJSON, !!opt_zoomSelfEnabled, !!opt_noClassnameMode );\r
BIND_WORKER_ARRAY.push( ret );\r
return ret;\r
},\r
/*
* pettanR system.js
- * version 0.5.39
+ * version 0.5.41
*
* gadgetOS
* author:
*
*/
var Class = ( function(){
- var CLASS_LIST = [],
- DEF_LIST = [],
- PRIVATE_LIST = [];
+ var CLASS_LIST = [],
+ DEF_LIST = [],
+ PRIVATE_CLASS_LIST = [],
+ PRIVATE_DEF_LIST = [],
+ CONSTRUCTOR = 'Constructor',
+ GET_INDEX = Util.getIndex,
+ abstractFlag = true,
+ privateFlag = true,
+ f = true,
+ c = Util.copyArray,
+ a; /* arguments */
function getClass( instance ){
- var list = CLASS_LIST,
- i = list.length,
- getIndex = Util.getIndex,
- klass, def, live, pool;
+ var cList = CLASS_LIST,
+ i = cList.length,
+ klass;
for( ; i; ){
- klass = list[ --i ];
- def = getDef( klass );
- if( def.live && getIndex( def.live, instance ) !== -1 ) return klass;
- if( def.pool && getIndex( def.pool, instance ) !== -1 ) return klass;
+ klass = cList[ --i ];
if( instance instanceof klass ) return klass;
};
- throw new Error( 'Class not found!' );
+ cList = PRIVATE_CLASS_LIST;
+ i = cList.length;
+ for( ; i; ){
+ klass = cList[ --i ];
+ if( instance instanceof klass ) return klass;
+ };
+
+ if( GET_INDEX( cList, instance ) !== -1 ) return instance;
+ if( GET_INDEX( CLASS_LIST, instance ) !== -1 ) return instance;
};
- function getDef( klass ){
- var i = Util.getIndex( CLASS_LIST, klass );
+ function getClassDef( KlassOrInstance ){
+ var getIndex = GET_INDEX,
+ i = getIndex( CLASS_LIST, KlassOrInstance );
+ if( i === -1 ) i = getIndex( CLASS_LIST, getClass( KlassOrInstance ) );
if( i !== -1 ) return DEF_LIST[ i ];
+
+ i = getIndex( PRIVATE_CLASS_LIST, KlassOrInstance );
+ if( i === -1 ) i = getIndex( PRIVATE_CLASS_LIST, getClass( KlassOrInstance ) );
+ if( i !== -1 ) return PRIVATE_DEF_LIST[ i ];
+
+ if( GET_INDEX( DEF_LIST, KlassOrInstance ) !== -1 ) return KlassOrInstance;
+ if( GET_INDEX( PRIVATE_DEF_LIST, KlassOrInstance ) !== -1 ) return KlassOrInstance;
};
/* over のプロパティを target にコピーする．ただし target の プロパティが優先, force で解除 */
function override( target, over, force ){
for( var p in over ){
+ if( p === CONSTRUCTOR ) continue;
if( force === true || typeof target[ p ] === 'undefined' ){
target[ p ] = over[ p ];
};
* var subClass = superClass.inherits( ... )
* http://d.hatena.ne.jp/m-hiyama/20051018/1129605002
*/
- function inherits( def, opt_pool, opt_abstract, opt_final, opt_super, opt_PrivateClass ){
- var Super = this,
- def = getDef( Super ),
- Traits, klass;
+ function inherits( /* displayName, classSetting, opt_PrivateClass, props */ ){
+ var args = c( arguments ),
+ params = [],
+ Super = this,
+ superDef = getClassDef( Super ),
+ displayName = args[ 0 ],
+ classSetting,
+ opt_super,
+ klass;
+ if( superDef.Final === true ) throw new Error( 'Class is final!' );
+
+ if( Type.isString( displayName ) === true ){
+ args.shift();
+ } else {
+ displayName = 'SubClass of ' + superDef.displayName;
+ };
+ params.push( displayName );
+
+ classSetting = args[ 0 ];
+ if( Type.isNumber( classSetting ) === true ){
+ opt_super = !!( classSetting & Class.SUPER_ACCESS );
+ params.push( args.shift() );
+ };
+ if( getClassDef( args[ 0 ] ) ){
+ params.push( args.shift() );
+ } else {
+ superDef.privateClass && params.push( superDef.privateClass );
+ };
+ params.push( override( new Super(), args[ 0 ], true ) ); /* props */
+
abstractFlag = false;
- Traits = new Super;
+ klass = Class.create.apply( null, params );
abstractFlag = true;
- klass = Class.create( override( Traits, def, true ), opt_pool, opt_abstract, opt_final, opt_PrivateClass );
- if( opt_super === true ){
- def.Super = Super.prototype;
- };
+ if( opt_super === true ) getClassDef( klass ).Super = Super.prototype;
return klass;
};
/* Class.create で作られたクラスのインスタンスが共通で備えるメソッド */
- var basic = {
+ var ClassBase = {
kill : function(){
var instance = this,
- p, v,
klass = getClass( instance ),
- def = getDef( klass ),
- privateData, i;
- Type.isFunction( o.onKill ) === true && o.onKill();
-
+ def = getClassDef( klass ),
+ privateData, p, i;
+ Type.isFunction( instance.onKill ) === true && instance.onKill();
for( p in instance ){
if( instance.hasOwnProperty && !instance.hasOwnProperty( p ) ) continue;
- v = instance[ p ];
delete instance[ p ];
};
if( def.pool ){
- klass.live.splice( Util.getIndex( klass.live, instance ), 1 );
- klass.pool.push( instance );
+ def.live && def.live.splice( GET_INDEX( def.live, instance ), 1 );
+ def.pool.push( instance );
};
if( def.privateClass ){
- privateData = instance.getPrivateData();
- privateData && privateData.kill();
+ privateData = klass.getPrivateData( instance );
+ if( privateData ){
+ privateData.kill();
+ i = GET_INDEX( def.dataList, privateData );
+ def.dataList.splice( i, 1 );
+ def.userList.splice( i, 1 );
+ };
};
- if( def.isPrivate === true ){
- i = Util.getIndex( def.dataList, instance );
- def.dataList.splice( i, 1 );
- def.userList.splice( i, 1 );
+ // myCallback の削除
+ // myCallback を受け取った API への通知
+ },
+ getMyCallback : function( callback ){
+ var def = getClassDef( this ),
+ iList = def.callbackInstanceList,
+ rList = def.callbackRegisterList,
+ i, cList, myCallback;
+ if( !iList ){
+ iList = def.callbackInstanceList = [];
+ rList = def.callbackRegisterList = [];
+ };
+ i = GET_INDEX( iList, this );
+ if( index === -1 ){
+ index = iList.length;
+ cList = [];
+ iList.push( this );
+ rList.push( cList );
+ } else {
+ cList = rList[ i ];
+ for( i = cList.length; i; ){
+ if( cList[ --i ].callback === callback ) return cList[ i ];
+ };
};
+ myCallback = new Callback( this, callback );
+ cList.push( myCallback );
+ return myCallback;
+ },
+ releaseMyCallback : function( callback ){
+ var def = getClassDef( this ),
+ iList = def.callbackInstanceList,
+ rList = def.callbackRegisterList,
+ i, cList, myCallback;
+ if( !iList ) return;
+ i = GET_INDEX( iList, this );
+ if( index === -1 ) return;
+ cList = rList[ i ];
+ i = GET_INDEX( cList, callback );
+ if( i !== -1 ) return;
+ myCallback = cList[ i ];
+ cList.splice( i, 1 );
+ myCallback.kill();
}
};
+
/* privateDataclass をもつクラスに追加されるメソッド */
- function newPrivateData( instance /*, args */ ){
- var klass = getDef( getClass( instance ) ).privateClass,
- def = getDef( klass ),
- i = Util.getIndex( def.userList, instance ),
- args = c( arguments ),
+ function newPrivateData( /* instance, args */ ){
+ var args = c( arguments ),
+ user = args.shift(),
+ def = getClassDef( user ),
+ privateClass = def.privateClass,
+ privateDef = getClassDef( privateClass ),
+ i = -1,
data;
- if( i === -1 ){
- throw new Error( 'Private already exist!' );
+ if( def.userList ){
+ i = GET_INDEX( def.userList, user );
+ } else {
+ def.userList = [];
+ def.dataList = [];
+ };
+ if( i !== -1 ){
+ throw new Error( 'PrivateData already exist!' );
};
privateFlag = false;
- args.unshift();
- data = I.apply( klass, args );
+ data = new privateClass();
privateFlag = false;
def.dataList.push( data );
- def.userList.push( instance );
+ def.userList.push( user );
+ privateDef[ CONSTRUCTOR ] && privateDef[ CONSTRUCTOR ].apply( data, args );
return data;
};
function getPrivateData( instance ){
- var klass = getDef( getClass( instance ) ).privateClass,
- def = getDef( klass ),
- i = Util.getIndex( def.userList, instance );
- if( i !== -1 ) return def.userList[ i ];
+ var def = getClassDef( instance ),
+ i = GET_INDEX( def.userList, instance );
+ if( i !== -1 ) return def.dataList[ i ];
};
/*
* new の実体．コンストラクタの機能は instance.Constructor に書く．
* これにより pool された オブジェクト（破棄されたインスタンス） を再利用できる
*/
- var abstractFlag = true,
- privateFlag = true,
- f = true,
- c = Util.copyArray,
- a, dataUser;
- function I(){
+ /* Constructor Real for GeneralClass */
+ function G(){
var klass = this,
- def = getDef( klass ),
- instance;
- if( def.abstract === true ){
- if( abstractFlag === true ){
- throw new Error( 'AbstractClass!' );
- };
+ def = getClassDef( klass ),
+ instance;
+ if( def.pool && def.pool.length > 0 ){
+ instance = def.pool.shift();
+ } else {
f = false;
instance = new klass();
f = true;
- return instance;
};
- if( def.isPrivate === true && privateFlag === true ){
+ if( def.Super && !instance.Super ){
+ instance.Super = def.Super;
+ };
+ def.live && def.live.push( instance );
+ def[ CONSTRUCTOR ] && def[ CONSTRUCTOR ].apply( instance, c( arguments ) );
+ return instance;
+ };
+
+ /* Constructor Real for PrivateClass */
+ function P(){
+ var klass = this,
+ def = getClassDef( klass ),
+ instance;
+ if( privateFlag === true ){
throw new Error( 'use class.newPrivateData( instance, args )!' );
};
if( def.pool && def.pool.length > 0 ){
instance = new klass();
f = true;
};
- if( def.Super ){
+ if( def.Super && !instance.Super ){
instance.Super = def.Super;
};
- instance.Constructor && instance.Constructor.apply( instance, c( arguments ) );
- def.live && def.live.push( instance );
return instance;
};
+ /* Constructor Real for AbstractClass */
+ function A(){
+ var klass = this,
+ instance;
+ if( abstractFlag === true ){
+ throw new Error( 'AbstractClass!' );
+ };
+ f = false;
+ instance = new klass();
+ f = true;
+ return instance;
+ };
+
return {
- create : function( def, opt_pool, opt_abstract, opt_final, opt_PrivateClass ){
- var klass = function(){
- a = arguments;
- if( f ) return I.apply( a.callee, c( a ) );
- },
- def = {},
- _def;
- klass.prototype = override( def, basic, false );
- if( opt_final === true && opt_abstract === true ){
- throw new Error( 'final & Abstract!' );
- };
- if( opt_final !== true ){
- klass.inherits = inherits;
+ POOL_OBJECT : 1,
+ ABSTRACT : 2,
+ FINAL : 4,
+ SUPER_ACCESS : 8,
+ PRIVATE_DATA : 16,
+ create : function( /* displayName, classSetting, opt_PrivateClass, props */ ){
+ var args = c( arguments ),
+ displayName = args[ 0 ],
+ classSetting,
+ opt_pool, opt_abstract, opt_final, opt_private,
+ privateDef,
+ props,
+ klass,
+ classDef = {};
+ if( Type.isString( displayName ) === true ){
+ classDef.displayName = displayName;
+ args.shift();
+ };
+ classSetting = args[ 0 ];
+ if( Type.isNumber( classSetting ) === true ){
+ opt_pool = !!( classSetting & Class.POOL_OBJECT );
+ opt_abstract = !!( classSetting & Class.ABSTRACT );
+ opt_final = !!( classSetting & Class.FINAL );
+ opt_private = !!( classSetting & Class.PRIVATE_DATA );
+ if( opt_final === true && opt_abstract === true ){
+ throw new Error( 'final & Abstract!' );
+ };
+ args.shift();
};
- if( opt_abstract === true ){
- def.abstract = true;
- } else
- if( opt_pool === true ){
- def.pool = [];
- def.live = [];
- };
- if( opt_PrivateClass ){
- _def = getDef( opt_PrivateClass );
- if( !_def || _def.isPrivate !== true ){
+ privateDef = getClassDef( args[ 0 ] );
+ if( privateDef ){
+ if( privateDef.isPrivate !== true ){
throw new Error( 'PrivateClass not found! please, Class.createPrivateData().' );
+ } else
+ if( privateDef.Abstract === true ){
+ throw new Error( 'PrivateClass is Abstract!' );
};
- def.privateClass = opt_PrivateClass;
- klass.newPrivateData = newPrivateData;
- klass.getPrivateData = getPrivateData;
+ classDef.privateClass = args.shift();
+ };
+ props = args[ 0 ];
+ if( props === null || Type.isObject( props ) === false ){
+ throw new Error( 'No Class Def!' );
+ };
+
+ if( Type.isFunction( props[ CONSTRUCTOR ] ) === true ){
+ classDef[ CONSTRUCTOR ] = props[ CONSTRUCTOR ];
+ };
+
+ if( opt_abstract === true ){
+ klass = function(){ a = arguments; if( f ) return A.apply( a.callee, c( a ) )};
+ classDef.Abstract = true;
+ } else
+ if( opt_private === true ){
+ klass = function(){ a = arguments; if( f ) return P.apply( a.callee, c( a ) )};
+ if( opt_pool === true ) classDef.pool = [];
+ } else {
+ klass = function(){ a = arguments; if( f ) return G.apply( a.callee, c( a ) )};
+ if( opt_pool === true ){
+ classDef.pool = [];
+ classDef.live = [];
+ };
+ };
+ klass.prototype = override( override( {}, props, true ), ClassBase, false );
+
+ if( opt_final === true ){
+ classDef.Final = true;
+ } else {
+ klass.inherits = inherits;
+ };
+ if( opt_private === true ){
+ if( classDef.privateClass ){
+ throw new Error( 'Private Data Class has no PrivateClass!' );
+ };
+ classDef.isPrivate = true;
+ PRIVATE_CLASS_LIST.push( klass );
+ PRIVATE_DEF_LIST.push( classDef );
+ } else {
+ if( classDef.privateClass ){
+ klass.newPrivateData = newPrivateData;
+ klass.getPrivateData = getPrivateData;
+ };
+ CLASS_LIST.push( klass );
+ DEF_LIST.push( classDef );
};
- CLASS_LIST.push( klass );
- DEF_LIST.push( def );
- return klass;
- },
- createPrivateData : function( def, opt_abstract, opt_final ){
- var klass = Class.create( def, true, opt_abstract, opt_final ),
- def = getDef( klass );
- def.isPrivate = true;
- def.userList = [];
- def.dataList = [];
return klass;
},
onShutdown : function(){
+ },
+ getClass : function( instance ){
+
+ },
+ getClassDef : function(){
+
}
};
})();
-var TicketBase = function(){
- this.kill = function(){
- var t = this, v, p;
- for( p in t ){
- if( t.hasOwnProperty && !t.hasOwnProperty( p ) ) continue;
- v = t[ p ];
- v && v instanceof TicketBase && v.kill();
- delete t[ p ];
+/**
+ * Callback 時に thisObject や args を指定したい場合に使用．
+ */
+var Callback = Class.create(
+ Class.POOL_OBJECT | Class.FINAL, {
+ Constructor : function( thisObject, callback, opt_args ){
+ if( Type.isFunction( callback ) === false ){
+ throw new Error( 'Not function!' );
+ };
+ this.callback = callback;
+ if( thisObject ) this.thisObject = thisObject;
+ if( Type.isArray( opt_args ) === true ){
+ this.args = opt_args;
+ } else
+ if( opt_args !== undefined ){
+ this.arg = opt_args;
};
- };
-};
-
+ },
+ fire : function( /* args */ ){
+ var thisObject = this.thisObject || window,
+ args = Util.copyArray( arguments );
+ if( 0 < args.length ){
+ if( this.args !== undefined ){
+ args.push.apply( args, this.args );
+ } else
+ if( this.arg !== undefined ){
+ args.push( this.arg );
+ };
+ this.callback.apply( thisObject, args );
+ } else {
+ if( this.args !== undefined ){
+ this.callback.apply( thisObject, this.args );
+ } else
+ if( this.arg !== undefined ){
+ this.callback.call( thisObject, this.arg );
+ } else {
+ this.callback.call( thisObject );
+ };
+ };
+ },
+ registerUser : function( user ){
+ if( !this.userList ){
+ this.userList = [ user ];
+ } else {
+ Util.getIndex( this.userList, user ) === -1 && this.userList.push( user );
+ };
+ },
+ onKill : function(){
+ var instance = this.thisObject;
+ this.userList && Class.getClass( instance ) && instance.releaseMyCalllback( this );
+ }
+});
/* --------------------------------------------------------------
var next = 0;
function loop(){
- for( var i = 0; i < TICKET_LIST.length; ) {
- if( TICKET_LIST[ i ].call( next ) !== false ) ++i;
+ var i = 0,
+ list = TICKET_LIST;
+ for( i = 0; i < list.length; ){
+ if( list[ i ].fire( next ) !== false ) ++i;
};
timerId = undefined;
update();
};
function update(){
- var l = TICKET_LIST.length,
- n = 99999999,
+ var list = TICKET_LIST,
+ l = list.length,
+ n = 99999999,
c;
if( l === 0 ){
timerId !== undefined && clearTimeout( timerId );
timerId = undefined;
return;
};
- for( var i = 0; i<l; i++ ){
- c = TICKET_LIST[ i ].count;
+ for( ; l; ){
+ c = list[ --l ].count;
if( n > c ) n = c;
};
if( next > n || timerId === undefined ){
};
};
- var TimerTicketClass = function( _apiuser, _callback, _time, _once, opt_thisObject ){
- this.apiuser = _apiuser;
- this.callback = _callback;
- this.time = _time;
- this.count = _time;
- this.once = _once;
- this.thisObj = opt_thisObject;
- };
- TimerTicketClass.prototype = new TicketBase();
- TimerTicketClass.prototype.call = function( c ){
- this.count -= c;
- if( this.count <= 0 ){
- this.callback.call( this.thisObj || this.apiuser );
- if( this.once === true ){
- this.destroy();
- TICKET_LIST.splice( Util.getIndex( TICKET_LIST, this ), 1 );
- return false;
- } else {
- this.count = this.time;
- };
- };
- };
- TimerTicketClass.prototype.destroy = function( _apiuser, _callback ){
- if( _apiuser && _apiuser !== this.apiuser ) return false;
- if( _callback && _callback !== this.callback ) return false;
-
- this.kill();
- return true;
- };
+ var TimerTicket = Class.create(
+ Class.POOL_OBJECT, {
+ Constructor : function( apiuser, callback, time, once, opt_thisObject ){
+ this.apiuser = apiuser;
+ this.callback = callback;
+ this.time = time;
+ this.count = time;
+ if( once ) this.once = once;
+ this.thisObj = opt_thisObject || apiuser;
+ },
+ fire : function( c ){
+ this.count -= c;
+ if( 0 < this.count ) return;
+ this.callback.call( this.thisObj );
+ if( this.once === true ){
+ this.destroy();
+ TICKET_LIST.splice( Util.getIndex( TICKET_LIST, this ), 1 );
+ return false;
+ } else {
+ this.count = this.time;
+ };
+ },
+ destroy : function( apiuser, callback ){
+ if( apiuser && apiuser !== this.apiuser ) return false;
+ if( callback && callback !== this.callback ) return false;
+
+ this.kill();
+ return true;
+ }
+ }
+ );
return {
add: function( _apiuser, _handler, _time, _once, opt_thisObject ){
if( Type.isNumber( _time ) === false || _time < INTERVAL_TIME ) _time = INTERVAL_TIME;
- var _ticket = new TimerTicketClass( _apiuser, _handler, Math.ceil( _time / INTERVAL_TIME ), _once, opt_thisObject );
+ var _ticket = new TimerTicket( _apiuser, _handler, Math.ceil( _time / INTERVAL_TIME ), _once, opt_thisObject );
TICKET_LIST.push( _ticket );
update();
*/
var AsyncCall = ( function(){
var CALLBACK_LIST = [];
-
- var CallbackTicketClass = function( _apiuser, _callback, _argments, _thisObject ){
- this.apiuser = _apiuser;
- this.callback = _callback;
- this.argments = _argments;
- this.thisObject = _thisObject;
- };
- CallbackTicketClass.prototype = new TicketBase();
- CallbackTicketClass.prototype.call = function(){
- var f = this.callback,
- a = this.argments,
- t = this.thisObject;
- this.destroy();
- if( Type.isArray( a ) === true ){
- f.apply( t, a );
- } else {
- f.call( t, a );
- };
- };
- CallbackTicketClass.prototype.destroy = function( _apiuser, _callback ){
- if( _apiuser && _apiuser !== this.apiuser ) return false;
- if( _callback && _callback !== this.callback ) return false;
-
- this.kill();
- return true;
- };
+
+ var CallbackTicket = Class.create(
+ Class.POOL_OBJECT, {
+ Constructor : function( apiuser, callback, args, thisObject ){
+ this.apiuser = apiuser;
+ this.callback = callback;
+ this.args = args;
+ this.thisObj = thisObject || apiuser;
+ },
+ fire : function(){
+ var f = this.callback,
+ a = this.args,
+ t = this.thisObj;
+ this.destroy();
+ if( Type.isArray( a ) === true ){
+ f.apply( t, a );
+ } else {
+ f.call( t, a );
+ };
+ },
+ destroy : function( apiuser, callback ){
+ if( apiuser && apiuser !== this.apiuser ) return false;
+ if( callback && callback !== this.callback ) return false;
+
+ this.kill();
+ return true;
+ }
+ });
function dispatch(){
var _ticket = CALLBACK_LIST.shift();
if( _ticket ){
- _ticket.call();
+ _ticket.fire();
CALLBACK_LIST.length !== 0 && SystemTimer.add( SUPER_USER_KEY, dispatch, 1, true );
};
};
return {
add: function( _apiuser, _callback, _argments, _thisObject ){
CALLBACK_LIST.length === 0 && SystemTimer.add( SUPER_USER_KEY, dispatch, 1, true );
- CALLBACK_LIST.push( new CallbackTicketClass( _apiuser, _callback, _argments, _thisObject || _apiuser ) );
+ CALLBACK_LIST.push( new CallbackTicket( _apiuser, _callback, _argments, _thisObject ) );
},
remove: function( _apiuser, _callback ){
var _ticket,
var REQUEST_TICKET_RESISTER = [],
currentTicket = null,
currentData = null,
- DATA_TYPE_ARRAY = 'json,xml,html,text'.split( ','),
+ DATA_TYPE_ARRAY = 'json,xml,html,text'.split( ',' ),
DATA_IS_JSON = 0,
DATA_IS_XML = 1,
DATA_IS_HTML = 2,
DATA_IS_TEXT = 3,
numError = 0;
- var RequestTicketClass = function( _apiuser, _type, _data, _url, _onLoad, _onError ){
- this.apiuser = _apiuser;
- this.type = _type;
- this.data = _data;
- this.url = _url;
- this.onLoad = _onLoad;
- this.onError = _onError;
- this.state = 0;
- _apiuser = _type = _data = _onLoad = _onError = null;
- };
- RequestTicketClass.prototype = new TicketBase();
- RequestTicketClass.prototype.load = function( _data ){
- AsyncCall.add( this.apiuser, this.onLoad, [ this.data, _data ] );
- };
- RequestTicketClass.prototype.error = function(){
- AsyncCall.add( this.apiuser, this.onError, this.data );
- };
+ var RequestTicket = Class.create(
+ Class.POOL_OBJECT, {
+ Constructor : function( apiuser, type, data, url, onLoad, onError ){
+ this.apiuser = apiuser;
+ this.type = type;
+ this.data = data;
+ this.url = url;
+ this.onLoad = onLoad;
+ this.onError = onError;
+ this.state = 0;
+ },
+ load : function( data ){
+ AsyncCall.add( this.apiuser, this.onLoad, [ this.data, data ] );
+ },
+ error : function(){
+ AsyncCall.add( this.apiuser, this.onError, this.data );
+ }
+ });
function request(){
if( currentTicket !== null || REQUEST_TICKET_RESISTER.length === 0 ) return;
return numError;
},
getJson: function( _apiuser, _data, _url, _onLoad, _onError ){
- REQUEST_TICKET_RESISTER.push( new RequestTicketClass( _apiuser, DATA_IS_JSON, _data, _url, _onLoad, _onError ));
+ REQUEST_TICKET_RESISTER.push( new RequestTicket( _apiuser, DATA_IS_JSON, _data, _url, _onLoad, _onError ));
currentTicket === null && request();
}
};
},
addEventListener: function( FILEorNULL, _eventType, _callback, opt_thisObject ){
var _uid = FILEorNULL instanceof FileClass ? FILEorNULL.getUID() : FILEorNULL;
- EVENT_LISTENER_REGISTER.push( new FileEventTicketClass( _uid, _eventType, _callback, opt_thisObject ));
- },
- removeEventListener: function( FILEorNULL, _eventType, _callback ){
- var _uid = FILEorNULL instanceof FileClass ? FILEorNULL.getUID() : FILEorNULL,
- _ticket;
- for(var i=0, l = EVENT_LISTENER_REGISTER.length; i<l; ++i ){
- _ticket = EVENT_LISTENER_REGISTER[ i ];
- if( _ticket.fileUID === _uid && _ticket.eventType === _eventType && _ticket.callBack === _callback ){
- EVENT_LISTENER_REGISTER.splice( i, 1 );
- _ticket.kill();
+ EVENT_LISTENER_REGISTER.push( new FileEventTicket( _uid, _eventType, _callback, opt_thisObject ));
+ },
+ removeEventListener: function( FILEorNULL, eventType, callback ){
+ var uid = FILEorNULL instanceof FileClass ? FILEorNULL.getUID() : FILEorNULL,
+ list = EVENT_LISTENER_REGISTER,
+ i = 0,
+ ticket;
+ for( ; i < list.length; ){
+ ticket = list[ i ];
+ if( ticket.fileUID === uid && ticket.eventType === eventType && ticket.callBack === callback ){
+ list.splice( i, 1 );
+ ticket.kill();
+ } else {
+ ++i;
};
};
},
return true;
};
};
-
- var FileEventTicketClass = function( uid, eventType, callback, opt_thisObject ){
- this.fileUID = uid;
- this.eventType = eventType;
- this.callBack = callback;
- this.thisObject = opt_thisObject;
- };
- FileEventTicketClass.prototype = new TicketBase();
+
+ var FileEventTicket = Class.create(
+ Class.POOL_OBJECT, {
+ Constructor : function( uid, eventType, callback, opt_thisObject ){
+ this.fileUID = uid;
+ this.eventType = eventType;
+ this.callBack = callback;
+ this.thisObject = opt_thisObject;
+ }
+ });
var FileEventClass = function( eventType, file, key, value ){
this.eventType = eventType;
var that = this;
this.button = ui.createButton( this.elm, function(){
that.onClick();
- that = null;
+ // that = null;
} );
this.app = app;
/**
* FinderPrivateData
*/
- var FinderPrivateData = function(){};
- FinderPrivateData.MIN_PATH_WIDTH = 25;
- FinderPrivateData.prototype = {
+ var FinderPrivateData = Class.create(
+ Class.PRIVATE_DATA, {
finder : null,
apiuser : null,
elmRoot : null,
panOutPage : null,
pageDetail : null,
currentFile : null,
- init : function( finder, apiuser, elm, tree, onSelect, viewerOption, editorOption ){
+ Constructor : function( finder, apiuser, elm, tree, onSelect, viewerOption, editorOption ){
this.finder = finder;
this.apiuser = apiuser;
if( PointingDeviceEventTree.isNodeInstance( elm ) === true ){
this.pageIcons1.init( this.nodeRoot, this.elmRoot, this.elmScroll );
this.pageIcons2.init( this.nodeRoot, this.elmRoot, this.elmScroll );
this.pageDetail.init( this );
- FinderPrivateData.LIST.push( this );
},
onIconClick : function( e ){
if( this.panInPage === this.pageDetail ) return;
AsyncCall.add( this.apiuser, this.draw, null, this );
};
},
- destroy : function(){
+ onKill : function(){
this.tree.removeTreeEventListener( Const.TREE.EVENT.UPDATE, this.draw );
if( this.pathList ){
i = Util.getIndex( list, this.finder );
i !== -1 && list.splice( i, 1 );
}
- };
- FinderPrivateData.LIST = [];
- FinderPrivateData.get = function( finderOrTree ){
- var list = FinderPrivateData.LIST,
- i = list.length,
- data;
- for( ; i; ){
- data = list[ --i ];
- if( data === finderOrTree || data.finder === finderOrTree || data.tree === finderOrTree ) return data;
- };
- return null;
- };
-
+ });
+ FinderPrivateData.MIN_PATH_WIDTH = 25;
+
/**
* FinderClass
*/
- var FinderClass = function( application, elmRoot, tree, onSelect, viewerOption, editorOption ){
- ( new FinderPrivateData() ).init( this, application, elmRoot, tree, onSelect, viewerOption, editorOption );
- };
- FinderClass.prototype = {
+ var Finder = Class.create(
+ FinderPrivateData, {
+ Constructor : function( application, elmRoot, tree, onSelect, viewerOption, editorOption ){
+ Finder.newPrivateData( this, this, application, elmRoot, tree, onSelect, viewerOption, editorOption );
+ },
MIN_WIDTH : 200,
MIN_HEIGHT : 200,
- init : function(){
- },
resize : function( w, h ){
- var data = FinderPrivateData.get( this );
+ var data = Finder.getPrivateData( this );
data.panInPage && data.panInPage.resize( w );
},
createPath : function( node ){
- return FinderPrivateData.get( this ).createPath( node );
+ return Finder.getPrivateData( this ).createPath( node );
},
destroy : function(){
- FinderPrivateData.get( this ).destroy();
+ this.kill();
}
- };
+ });
return {
init: function(){
create: function( application, elmTarget, tree, onSelect, viewerOption, editorOption ){
//if( Application.isApplicationInstance( _application ) === false ) return;
- var finder = new FinderClass( application, elmTarget, tree, onSelect, viewerOption, editorOption );
- finder.init();
+ var finder = new Finder( application, elmTarget, tree, onSelect, viewerOption, editorOption );
FINDER_LIST.push( finder );
return finder;
},
},
isFinderInstance: function( _finder ){
- return _finder instanceof FinderClass;
+ return _finder instanceof Finder;
},
isFinderPaneInstance: function(){
OSDN Git Service
