app/assets/javascripts/system.js

   1 /*
   2  * pettanR system.js
   3  *   version 0.4.1
   4  *
   5  * author:
   6  *   itozyun
   7  * licence:
   8  *   3-clause BSD
   9  */
  10
  11
  12 pettanr.log = ( function(){
  13         return {
  14                 init: function(){}
  15         }
  16 })();
  17
  18 pettanr.io = ( function(){
  19
  20         return {
  21                 init: function(){}
  22         }
  23 })();
  24
  25 /*
  26  * 画像一覧は
  27  *      お気に入り画像一覧 > tag:ペン次郎 > ペン次郎：笑う
  28  *  最近アップロードされた画像 > images
  29  *  最近使われた画像 > images
  30  *  キャラクター画像庫 > アニマル系 > tag:ペン次郎 > ペン次郎：笑う
  31  *  風景画像庫 >
  32  *  効果画像庫 >
  33  *  アイテム画像庫 >
  34  *
  35  * 画像一覧を読み込むタイミング
  36  */
  37 pettanr.file = ( function(){
  38         var TREE_TYPE_IS_COMIC = 1,
  39                 TREE_TYPE_IS_IMAGE = 2,
  40                 FILE_TYPE_IS_FOLDER = 1,
  41                 FILE_TYPE_IS_COMIC = 10,
  42                 FILE_TYPE_IS_PANEL = 11,
  43                 FILE_TYPE_IS_IMAGE = 20,
  44                 FILE_TYPE_IS_HTML = 30,
  45                 FILE_TYPE_IS_SETTING = 40,
  46                 FOLDER_TYPE_IS_COMIC = 1,
  47                 FILE_STATE_IS_UNKNOWN = 0,
  48                 FILE_STATE_IS_OK = 1,
  49                 FILE_STATE_IS_LOADING = 2,
  50                 FILE_STATE_IS_ERROR = 3,
  51                 FILE_STATE_IS_BROKEN = 4,
  52                 TREE_EVENT_UPDATE = 'onTreeUpdate',
  53                 FILE_EVENT_UPDATE_ATTRIVUTE = 'onFileUpdate',
  54                 FILE_EVENT_GET_SEQENTIAL_FILES = 'gotSeqentilFiles',
  55                 ROLE_IS_SUPER_USER = 2^4,
  56                 ROLE_IS_OWNER = 2^3,
  57                 ROLE_IS_CREATOR = 2^2,
  58                 ROLE_IS_ARTIST = 2^1,
  59                 ROLE_IS_VISITOR = 2^0,
  60                 ROLE_IS_UNKROWN = 2^-1,
  61                 UPDATE_POLICY_SOCAV = 0x11111,// s: super user
  62                 UPDATE_POLICY_SOCA_ = 0x11110,// o: owner( comic || panel || picture )
  63                 UPDATE_POLICY_SOC__ = 0x11100,// c: creator
  64                 UPDATE_POLICY_SO_A_ = 0x11010,// a: artist
  65                 UPDATE_POLICY_SO___ = 0x11000,// v: visitor
  66                 UPDATE_POLICY__O___ = 0x01000,// l: lisence manager
  67                 UPDATE_POLICY_S____ = 0x10000,
  68                 UPDATE_POLICY______ = 0x00000,
  69                 FILEDATA_RESITER = [],
  70                 FILEDATA_HAS_rID_RESISTER = {},
  71                 FILEDATA_ACCESS = [],
  72                 FILE_OBJECT_POOL = [];
  73
  74         var REQUEST_CONTROLER = ( function(){
  75                 var REQUEST_TICKET_RESISTER = [],
  76                         DATA_TYPE_ARRAY = 'json,xml,html,text'.split( ','),
  77                         DATA_IS_JSON = 0,
  78                         DATA_IS_XML = 1,
  79                         DATA_IS_HTML = 2,
  80                         DATA_IS_TEXT = 3,
  81                         numError = 0;
  82
  83                 var RequestTicketClass = function( _type, _data, _url, _onLoad, _onError){
  84                         this.type = DATA_TYPE_ARRAY[ _type];
  85                         this.data = _data;
  86                         this.url = _url;
  87                         this.onLoad = _onLoad;
  88                         this.onError = _onError;
  89                         this.state = 0;
  90                 };
  91
  92                 function request(){
  93                         if( REQUEST_TICKET_RESISTER.length === 0) return;
  94                         var _ticket = REQUEST_TICKET_RESISTER.shift();
  95                         $.ajax({
  96                                 url:            _ticket.url,
  97                                 dataType:       _ticket.type,
  98                                 success:        function( _data){
  99                                         _ticket.onLoad( _ticket.data, _data);
 100                                 },
 101                                 error:          function(){
 102                                         ++numError;
 103                                         _ticket.onError( _ticket.data);
 104                                 }
 105                         });
 106                 }
 107
 108                 return {
 109                         init: function(){
 110                                 delete REQUEST_CONTROLER.init;
 111                         },
 112                         getNumTask: function(){
 113                                 return REQUEST_TICKET_RESISTER.length;
 114                         },
 115                         getNumError: function(){
 116                                 return numError;
 117                         },
 118                         getJson: function( _data, _url, _onLoad, _onError){
 119                                 REQUEST_TICKET_RESISTER.push( new RequestTicketClass( DATA_IS_JSON, _data, _url, _onLoad, _onError));
 120                                 request();
 121                         }
 122                 }
 123         })();
 124
 125
 126
 127         var FILE_CONTROLER = ( function(){
 128                 var EVENT_LISTENER_RESISTER = [],
 129                         TREE_ARRAY = [],
 130                         TREE_ACCESS_ARRAY = [],
 131                         instance;
 132
 133                 var TreeClass = function( ROOTFILE_DATA){
 134                         var UID = TREE_ACCESS_ARRAY.length,
 135                                 PARENT_FILE_RESITER = [],
 136                                 ACCESS = {
 137                                         fileEventChatcher:      dispatchFileEvent,
 138                                         destroy:                        onDestroy
 139                                 },
 140                                 EVENT_LISTENER_ARRAY = [],
 141                                 rootFile,
 142                                 rootFileData,
 143                                 currentFile,
 144                                 currentFileData,
 145                                 instance;
 146
 147                         TREE_ACCESS_ARRAY.push( ACCESS);
 148
 149                         function onDestroy(){
 150
 151                         }
 152
 153                         function dispatchFileEvent( e){
 154                                 var _eventType = e.eventType,
 155                                         _targetFile = e.targetFile,
 156                                         _ticket, _type, _file, _callback,
 157                                         l = EVENT_LISTENER_RESISTER.length;
 158                                 for(var i=0; i<l; ++i){
 159                                         _ticket = EVENT_LISTENER_RESISTER[i],
 160                                         _type = _ticket.eventType,
 161                                         _file = _ticket.targetFile,
 162                                         _callback = _ticket.callBack;
 163                                         if( _eventType === _type && _file.getUID() === _targetFile.getUID()){
 164                                                 _callback( _type, _targetFile, e.key, e.value);
 165                                         } else if( _type === TREE_EVENT_UPDATE && _eventType === FILE_EVENT_GET_SEQENTIAL_FILES){
 166                                                 _callback( TREE_EVENT_UPDATE, _targetFile);
 167                                         }
 168                                 }
 169                         }
 170
 171                         return {
 172                                 init: function(){
 173                                         instance = this;
 174                                         currentFile = rootFile = new FileClass( this, null, ROOTFILE_DATA);
 175                                         rootFile.init();
 176                                         FILE_CONTROLER.getSeqentialFiles( currentFile);
 177                                         delete this.init;
 178                                 },
 179                                 getUID: function(){ return UID},
 180                                 getRootFile : function(){
 181                                         return rootFile;
 182                                 },
 183                                 getCurrentFile: function(){
 184                                         return currentFile;
 185                                 },
 186                                 hierarchy: function(){
 187                                         return PARENT_FILE_RESITER.length;
 188                                 },
 189                                 getParentFileAt: function( _index){
 190                                         var l = PARENT_FILE_RESITER.length;
 191                                         if( typeof _index !== 'number' || _index < 0 || _index >= l) return null;
 192                                         return PARENT_FILE_RESITER[ l -1 -_index];
 193                                 },
 194                                 down: function( _index){
 195                                         if( typeof _index !== 'number' || _index < 0 || _index >= currentFile.getChildFileLength()) return;
 196                                         PARENT_FILE_RESITER.unshift( currentFile);
 197                                         currentFile = currentFile.getChildFileByIndex( _index);
 198                                         FILE_CONTROLER.getSeqentialFiles( currentFile);
 199                                         return currentFile;
 200                                 },
 201                                 up: function( _index){
 202                                         var l = PARENT_FILE_RESITER.length;
 203                                         if( l === 0) return null;
 204                                         if( typeof _index === 'number'){
 205                                                 if( _index >= l) return null;
 206                                                 currentFile = this.getParentFileAt( _index);
 207                                                 PARENT_FILE_RESITER.splice( 0, l -_index);
 208                                         } else {
 209                                                 currentFile = PARENT_FILE_RESITER.shift();
 210                                         }
 211                                         FILE_CONTROLER.getSeqentialFiles( currentFile);
 212                                         return currentFile;
 213                                 },
 214                                 addTreeEventListener: function( _eventType, _callback){
 215                                         EVENT_LISTENER_RESISTER.push( new FileEventTicketClass( null, _eventType, _callback));
 216                                 },
 217                                 removeTreeEventListener: function( _eventType, _callback){
 218
 219                                 },
 220                                 createSearchResultFolder: function( _searchParam){
 221
 222                                 },
 223                                 destroySearchResultFolder: function( _searchParam){
 224
 225                                 },
 226                                 destroy: function(){
 227                                         destroyTree( UID);
 228                                 }
 229                         }
 230                 };
 231                 /**
 232                  * _access.DATA === FILEDATA_RESITER[uid]
 233                  */
 234                 function getFileDataAccess( UIDorFILEorFILEDATA){
 235                         var l = FILEDATA_ACCESS.length,
 236                                 _uid,
 237                                 _data,
 238                                 _access;
 239
 240                         if( typeof UIDorFILEorFILEDATA === 'number'){
 241                                 _data = FILEDATA_RESITER[ UIDorFILEorFILEDATA] || null;
 242                         } else
 243                         if( UIDorFILEorFILEDATA.getUID){
 244                                 _uid = UIDorFILEorFILEDATA.getUID();
 245                                 _data = FILEDATA_RESITER[ _uid] || null;
 246                         } else {
 247                                 _data = UIDorFILEorFILEDATA;
 248                         }
 249
 250                         if( _data === null || !_data) return null;
 251                         for(var i=0; i<l; ++i){
 252                                 _access = FILEDATA_ACCESS[ i];
 253                                 if( _access.DATA === _data) return _access;
 254                         }
 255                         return null;
 256                 }
 257                 function getChildren( UIDorFILE){
 258                         var _access = getFileDataAccess( UIDorFILE);
 259                         return  _access !== null ? _access.CHILDREN : null
 260                 }
 261                 function onLoadJson( _file, _json){
 262                         var _access = getFileDataAccess( _file),
 263                                 _data = _access !== null ? _access.DATA : null,
 264                                 l = _json.length,
 265                                 _fileData;
 266                         if( _data == null){
 267                                 onErrorJson( _file);
 268                                 return;
 269                         }
 270                         if( l === 0) return;
 271                         if( !_data.children){
 272                                 _data.children = [];
 273                         }
 274                         var _children = _data.children,
 275                                 _childType = _data.childType,
 276                                 _newData,
 277                                 _rFolderData,
 278                                 _artistFolderData, _artistFolder,
 279                                 _comicFolderData, _comicFolder,
 280                                 _authorFolderData, _authorFolder;
 281
 282                         for(var i=0; i<l; ++i){
 283                                 _newData = buildFileData( _json[ i], _data.json, _childType);
 284                                 if( _newData.rID){
 285                                         _rFolderData = getFolderDataByResourceID( buildResourceID( _data.json, _childType), _childType, _file);
 286                                         _rFolderData.children.push( _newData);
 287                                 }
 288                                 if( _newData.artist){
 289                                         _artistFolderData = _artistFolderData || getFolderDataByResourceID( buildResourceID( _data.json, 'artist'), 'Artists', _file);
 290                                         _artistFolder = _artistFolder || new FileClass( SYSTEM_TREE, _file, _artistFolderData);
 291                                         _rFolderData = getFolderDataByResourceID( buildResourceID( _artistFolderData.rID, '' +_newData.artist.id), _newData.artist.name, _artistFolder);
 292                                         _rFolderData.children.push( _newData);
 293                                 }
 294                                 if( _newData.comic){
 295                                         _comicFolderData = _comicFolderData || getFolderDataByResourceID( buildResourceID( _data.json, 'comic'), 'Comics', _file);
 296                                         _comicFolder = _comicFolder || new FileClass( SYSTEM_TREE, _file, _comicFolderData);
 297                                         _rFolderData = getFolderDataByResourceID( buildResourceID( _comicFolderData.rID, '' +_newData.comic.id), _newData.comic.title, _comicFolder);
 298                                         _rFolderData.children.push( _newData);
 299                                 }
 300                                 if( _newData.author){
 301                                         _authorFolderData = _authorFolderData || getFolderDataByResourceID( buildResourceID( _data.json, 'author'), 'Author', _file);
 302                                         _authorFolder = _authorFolder || new FileClass( SYSTEM_TREE, _file, _authorFolderData);
 303                                         _rFolderData = getFolderDataByResourceID( buildResourceID( _authorFolderData.rID, '' +_newData.author.id), _newData.author.name, _authorFolder);
 304                                         _rFolderData.children.push( _newData);
 305                                 }
 306                         }
 307                         delete _data.json;
 308                         _artistFolder && _artistFolder.collect();
 309                         _comicFolder && _comicFolder.collect();
 310                         _authorFolder && _authorFolder.collect();
 311                         _access.fileEventChatcher( new FileEventClass( FILE_EVENT_GET_SEQENTIAL_FILES, _file, 'children', null));
 312                 }
 313                 function onErrorJson( _file){
 314                         var _access = getFileDataAccess( _file),
 315                                 _data = _access !== null ? _access.DATA : null;
 316                         if( _data !== null){
 317                                 _data.state = FILE_STATE_IS_ERROR;
 318                         }
 319                 }
 320                 function buildFileData( _data, _url, _type){
 321                         if( !_data.name){
 322                                 _data.name = [ _data.id, _data.ext].join( '.');
 323                         }
 324                         _data.type = _type;
 325
 326                         if( _type === FILE_TYPE_IS_IMAGE){
 327                                 _data.thumbnail = 'thumbnail/' + _data.name;
 328                         }
 329
 330                         var _rID = buildResourceID( _url, _type);
 331                         if( _rID !== null){
 332                                 _data.rID = _rID + _data.id;
 333                                 FILEDATA_HAS_rID_RESISTER[ _data.rID] = _data;
 334                         }
 335
 336                         FILEDATA_RESITER.push( _data);
 337
 338                         return _data;
 339                 }
 340                 function buildResourceID( _url, _type){
 341                         if( _url === null) return null;
 342                         var _typeStr;
 343
 344                         if( typeof _type !== 'number'){
 345                                 _typeStr = _type
 346                         } else
 347                         if( _type === FILE_TYPE_IS_IMAGE){
 348                                 _typeStr = 'image';
 349                         } else
 350                         if( _type === FILE_TYPE_IS_COMIC){
 351                                 _typeStr = 'comic';
 352                         }
 353                         if( _type === FILE_TYPE_IS_PANEL){
 354                                 _typeStr = 'panel';
 355                         }
 356                         return [ _url.replace(/https?:\/\/([^\/]*).*/, '$1'), _typeStr].join('_');
 357                 }
 358         /**
 359          * getFileByResourceID( _rID, opt_name, opt_folder)
 360          * opt 指定で 新しいフォルダの作成
 361          * rID を持つ Object は {} にも格納．
 362          */
 363                 function getFolderDataByResourceID( _rID, opt_name, opt_folder){
 364                         if( FILEDATA_HAS_rID_RESISTER[ _rID]){
 365                                 return FILEDATA_HAS_rID_RESISTER[ _rID];
 366                         }
 367                         if( !opt_name && !opt_folder) return;
 368
 369                         var _fileName;
 370
 371                         if( typeof opt_name === 'string'){
 372                                 _fileName = opt_name;
 373                         } else
 374                         if( opt_name === FILE_TYPE_IS_IMAGE){
 375                                 _fileName = 'Pictures';
 376                         } else
 377                         if( opt_name === FILE_TYPE_IS_COMIC){
 378                                 _fileName = 'Comics';
 379                         } else
 380                         if( opt_name === FILE_TYPE_IS_PANEL){
 381                                 _fileName = 'Panels';
 382                         } else {
 383                                 _fileName = opt_name.toString();
 384                         }
 385
 386                         var _newData = {
 387                                 name:           _fileName,
 388                                 type:           FILE_TYPE_IS_FOLDER,
 389                                 rID:            _rID,
 390                                 children:       []
 391                         };
 392                         FILEDATA_RESITER.push( _newData);
 393                         FILEDATA_HAS_rID_RESISTER[ _rID] = _newData;
 394
 395                         if( opt_folder && opt_folder.isChildFile( _newData) === false){
 396                                 var _access = getFileDataAccess( opt_folder),
 397                                         _data = _access !== null ? _access.DATA : null;
 398                                 _access === null && alert( _rID)
 399                                 if( _data !== null){
 400                                         _data.children.push( _newData);
 401                                 }
 402                         }
 403
 404                         return _newData;
 405                 }
 406
 407                 function destroyTree(){
 408
 409                 }
 410
 411                 return {
 412                         init: function(){
 413                                 instance = this;
 414                                 delete FILE_CONTROLER.init;
 415                         },
 416                         createTree: function( _rootFileData){
 417                                 var _tree = new TreeClass( _rootFileData);
 418                                 _tree.init();
 419                                 TREE_ARRAY.push( _tree);
 420                                 return _tree;
 421                         },
 422                         getFileData: function( _file){
 423                                 var _access = getFileDataAccess( _file);
 424                                 return _access !== null ? _access.DATA : null;
 425                         },
 426                         getUID: function ( _filedata){
 427                                 var l = FILEDATA_RESITER.length;
 428                                 for( var i=0; i<l; ++i){
 429                                         if( FILEDATA_RESITER[ i] === _filedata) return i;
 430                                 }
 431                                 return -1;
 432                         },
 433                         getSeqentialFiles: function( _file){
 434                                 var _data = this.getFileData( _file),
 435                                         _json = _data ? _data.json : null;
 436                                 if( _json !== null){
 437                                         REQUEST_CONTROLER.getJson( _file, _json, onLoadJson, onErrorJson);
 438                                 }
 439                         },
 440                         updateFileAttribute: function( _uid, key, _value, _opt_callback){
 441                                 var _data = getFileDataAccess( _uid),
 442                                         _type = _data.TYPE;
 443
 444                         },
 445                         getFileAttribute: function( _uid, KEYorKEYARRAY){
 446                                 var _fileData = getFileDataAccess( _uid),
 447                                         _type = _fileData.TYPE;
 448                         },
 449                         move: function( _prentUID, _targetfile, _newFolder, _newIndex, _opt_callback){
 450                                 var _parentData = getFileDataAccess( _prentUID),
 451                                         _parentType = _parentData.TYPE,
 452                                         _targetData = getFileDataAccess( _targetfile),
 453                                         _targetType = _targetData.TYPE;
 454                         },
 455                         replace: function( _uid, _file, _newIndex){
 456
 457                         },
 458                         fileEventRellay: function( _targetFile, _targetTree, _event){
 459                                 var _uid = _targetTree.getUID(),
 460                                         _access = TREE_ACCESS_ARRAY[ _uid],
 461                                         l = TREE_ARRAY.length,
 462                                         _tree, _currentFile;
 463                                 _access !== undefined && _access.fileEventChatcher( _event);
 464                                 for(var i=0; i<l; ++i){
 465                                         if( i !== _uid){
 466                                                 _tree = TREE_ARRAY[i];
 467                                                 _currentFile = _tree.getCurrentFile();
 468                                                 if( FILE_CONTROLER.getFileData( _currentFile) === _access.DATA){
 469                                                         _tree.fileEventChatcher( _event);
 470                                                 }
 471                                         }
 472                                 }
 473                         }
 474                 }
 475         })();
 476
 477         var FileEventTicketClass = function( UID, _eventType, _callback){
 478                 return {
 479                         fileUID:        UID,
 480                         eventType:      _eventType,
 481                         callBack:       _callback,
 482                         destroy: function(){
 483                                 this.callBack = _callback = null;
 484                         }
 485                 }
 486         }
 487
 488         var FileEventClass = function( eventType, file, key, value){
 489                 return {
 490                         eventType:                      eventType,
 491                         targetFile:                     file,
 492                         updatedAttribute:       key,
 493                         updatedValue:           value
 494                 }
 495         }
 496
 497 /*
 498  * fileのdataはobjectで保持している。
 499  * pettanr.file.の外からファイルをみるときは、FileClassを通して操作する。
 500  * fileの変更、それに付随して追加されたイベントは、TreeClassで管理される。
 501  * treeがdestryされると、fileのイベントリスナーも全て削除される。
 502  * 他の tree も data の共通する currentFile に対してのみは、file の変更イベントを受け取って流す．
 503  */
 504
 505         var FileClass = function( TREE, parentFile, data){
 506                 if( !data.children){
 507                         data.children = [];
 508                 }
 509                 var TYPE = data.type,
 510                         uid = FILE_CONTROLER.getUID( data),
 511                         CHILDREN = data.children,
 512                         instance;
 513
 514                 if( uid === -1){
 515                         //alert( 'invalid uid');
 516                         uid = FILEDATA_RESITER.length;
 517                         FILEDATA_RESITER.push( data);
 518                 }
 519
 520                 FILEDATA_ACCESS.push(
 521                         {
 522                                 TYPE:                           TYPE,
 523                                 DATA:                           data,
 524                                 CHILDREN:                       CHILDREN,
 525                                 destroy:                        destroy,
 526                                 updateParent:           updateParent,
 527                                 fileEventChatcher:      dispatchEvent
 528                         }
 529                 );
 530                 function destroy(){
 531                         CHILDREN.splice( 0, CHILDREN.length);
 532                         parentFile = data = CHILDREN = null;
 533                         delete this.destroy;
 534                 }
 535                 function updateParent( _parent){
 536                         parentFile = _parent;
 537                 }
 538                 function dispatchEvent( e){
 539                         FILE_CONTROLER.fileEventRellay( instance, TREE, e);
 540                 }
 541                 return {
 542                         init: function(){
 543                                 instance = this;
 544                                 delete this.init;
 545                         },
 546                         TYPE: function(){ return TYPE;},
 547                         getName: function(){
 548                                 return data.name || 'no_name';
 549                         },
 550                         getThumbnail: function(){
 551                                 return data.thumbnail || null;
 552                         },
 553                         getUID: function(){
 554                                 return uid;
 555                         },
 556                         getState: function(){
 557                                 return data.state !== undefined ? data.state : FILE_STATE_IS_OK;
 558                         },
 559                         getChildFileLength: function(){
 560                                 return CHILDREN && typeof CHILDREN.length === 'number' ? CHILDREN.length : 0;
 561                         },
 562                         getChildFileByIndex: function( _index){
 563                                 if( typeof _index !== 'number' || _index < 0 || typeof CHILDREN.length !== 'number' || _index >= CHILDREN.length) return null;
 564                                 _file = new FileClass( TREE, this, CHILDREN[ _index]);
 565                                 _file.init();
 566                                 return _file;
 567                         },
 568                         getChildFileIndex: function( _FILEorFILEDATA){
 569                                 if( !CHILDREN || typeof CHILDREN.length !== 'number') return -1;
 570                                 var l = FILEDATA_RESITER.length,
 571                                         _fileData = null;
 572                                 for( var i=0; i<l; ++i){
 573                                         if( _FILEorFILEDATA === FILEDATA_RESITER[ i]){
 574                                                 _fileData = _FILEorFILEDATA;
 575                                                 break;
 576                                         };
 577                                 }
 578                                 if( _fileData === null){
 579                                         _fileData = FILE_CONTROLER.getFileData( _FILEorFILEDATA);
 580                                 }
 581                                 if( _fileData === null) return -1;
 582
 583                                 l = CHILDREN.length
 584                                 for( var i=0; i<l; ++i){
 585                                         if( CHILDREN[ i] === _fileData) return i;
 586                                 }
 587                                 return -1;
 588                         },
 589                         isChildFile: function( _FILEorFILEDATA){
 590                                 return this.getChildFileIndex( _FILEorFILEDATA) !== -1;
 591                         },
 592                         getAttribute: function( KEYorKEYARRAY){
 593                                 return FILE_CONTROLER.getFileAttribute( UID, KEYorKEYARRAY);
 594                         },
 595                         getSeqentialFiles: function(){
 596                                 FILE_CONTROLER.getSeqentialFiles( this);
 597                         },
 598                         updateAttribute: function( key, value, opt_callback){
 599                                 TREE.updateFileAttribute( UID, key, value, opt_callback);
 600                         },
 601                         move: function( _newFolder, _newIndex, opt_callback){
 602                                 TREE.move( parentFile, UID, _newFolder, _newIndex, opt_callback);
 603                         },
 604                         replace: function( _newIndex, opt_callback){
 605                                 TREE.replace( parentFile, UID, _newIndex, opt_callback);
 606                         },
 607                         addEventListener: function( _eventType, _callback){
 608                                 FILE_CONTROLER.addEventListener( UID, _eventType, _callback);
 609                         },
 610                         removeEventListener: function( _eventType, _callback){
 611                                 FILE_CONTROLER.removeEventListener( UID, _eventType, _callback);
 612                         },
 613                         collect: function(){
 614
 615                         }
 616                 }
 617         };
 618         function getFileObject( TREE, parentFile, data){
 619                 var _file;
 620                 if( FILE_OBJECT_POOL.length > 0){
 621                         _file = FILE_OBJECT_POOL.shift();
 622                 } else {
 623                         _file = new FileClass();
 624                 }
 625                 _file.init( TREE, parentFile, data);
 626                 return _file;
 627         }
 628
 629         var ROOT_FILEDATA = {
 630                         name:           'root',
 631                         type:           FILE_TYPE_IS_FOLDER,
 632                         children:       []
 633                 },
 634                 IMAGE_FILEDATA = {
 635                         name:           'image root',
 636                         type:           FILE_TYPE_IS_FOLDER,
 637                         json:           pettanr.CONST.URL_ORIGINAL_PICTURES_JSON,
 638                         children:       [
 639                                 {
 640                                         name:           'My Pictures',
 641                                         type:           FILE_TYPE_IS_FOLDER,
 642                                         children:       [],
 643                                         childType:      FILE_TYPE_IS_IMAGE
 644                                 }
 645                         ],
 646                         childType:      FILE_TYPE_IS_IMAGE
 647                 },
 648                 COMIC_FILEDATA = {
 649                         name:           'comic root',
 650                         type:           FILE_TYPE_IS_FOLDER,
 651                         json:           pettanr.CONST.URL_PANELS_JSON,
 652                         children:       [
 653                                 {
 654                                         name:           'My Comics',
 655                                         type:           FILE_TYPE_IS_FOLDER,
 656                                         children:       [],
 657                                         childType:      FILE_TYPE_IS_COMIC
 658                                 }
 659                         ],
 660                         childType:      FILE_TYPE_IS_PANEL
 661                 };
 662         //FILEDATA_RESITER.push( ROOT_FILEDATA, IMAGE_FILEDATA, IMAGE_FILEDATA.children[0], COMIC_FILEDATA);
 663         ROOT_FILEDATA.children.push( COMIC_FILEDATA, IMAGE_FILEDATA);
 664
 665         var SYSTEM_TREE = FILE_CONTROLER.createTree( ROOT_FILEDATA),
 666                 ROOT_FILE = SYSTEM_TREE.getRootFile(),
 667                 COMIC_ROOT_INDEX = ROOT_FILE.getChildFileIndex( COMIC_FILEDATA),
 668                 IMAGE_ROOT_INDEX = ROOT_FILE.getChildFileIndex( IMAGE_FILEDATA);
 669
 670         return {
 671                 init: function(){
 672                         REQUEST_CONTROLER.init();
 673                         FILE_CONTROLER.init();
 674                         delete pettanr.file.init;
 675                 },
 676                 createTree: function( _treeType){
 677                         var _rootFile;
 678                         if( _treeType === TREE_TYPE_IS_COMIC) _rootFile = COMIC_FILEDATA;
 679                         if( _treeType === TREE_TYPE_IS_IMAGE) _rootFile = IMAGE_FILEDATA;
 680                         if( _rootFile === undefined) return;
 681                         return FILE_CONTROLER.createTree( _rootFile);
 682                 },
 683                 TREE_TYPE_IS_COMIC:             1,
 684                 TREE_TYPE_IS_IMAGE:             2,
 685                 TREE_TYPE_IS_SETTING:   3,
 686                 FILE_TYPE_IS_FOLDER:    FILE_TYPE_IS_FOLDER,
 687                 FILE_TYPE_IS_IMAGE:             FILE_TYPE_IS_IMAGE,
 688                 FILE_TYPE_IS_PANEL:             FILE_TYPE_IS_PANEL,
 689                 FILE_TYPE_IS_SETTING:   FILE_TYPE_IS_SETTING
 690         }
 691 })();
 692
 693 pettanr.finder = ( function(){
 694         var FINDER_ARRAY = [],
 695                 ELM_ORIGIN_FINDER_LOCATION_ITEM = pettanr.util.pullHtmlAsTemplete( 'templete-finder-location-item'),
 696                 ELM_ORIGIN_FINDER_ICON = pettanr.util.pullHtmlAsTemplete( 'templete-finder-icon'),
 697                 ELM_ORIGIN_CONTAINER = pettanr.util.pullHtmlAsTemplete( 'templete-finder-container'),
 698                 ICON_HEIGHT = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON).height,
 699                 ICON_CLASSNAME = ELM_ORIGIN_FINDER_ICON.getElementsByTagName( 'div')[0].className,
 700                 FINDER_ICON_POOL = [],
 701                 BREAD_OBJECT_POOL = [];
 702
 703         var FinderIconClass = function(){
 704                 var elmContainer,
 705                         ELM_WRAPPER = ELM_ORIGIN_FINDER_ICON.cloneNode( true),
 706                         ELM_THUMBNAIL = ELM_WRAPPER.getElementsByTagName( 'div')[0],
 707                         ELM_FILENAME = ELM_WRAPPER.getElementsByTagName( 'div')[1],
 708                         file, w, index, style, instansce, callback;
 709
 710                 ELM_WRAPPER.onclick = onClick;
 711                 function onClick(){
 712                         callback( index);
 713                 }
 714
 715
 716                 function draw(){
 717                         var _thumb = file.getThumbnail();
 718                         if( _thumb !== null){
 719                                 ELM_THUMBNAIL.className = ICON_CLASSNAME + ' has-thumbnail';
 720                                 ELM_THUMBNAIL.style.backgroundImage = [ 'url(', _thumb, ')'].join( '');
 721                         } else {
 722                                 ELM_THUMBNAIL.className = ICON_CLASSNAME + ' file-type-' +file.TYPE();
 723                                 ELM_THUMBNAIL.style.backgroundImage = '';
 724                         }
 725                         ELM_FILENAME.innerHTML = file.getName();
 726                 }
 727                 function resize(){
 728                         ELM_WRAPPER.style.top = (index * ICON_HEIGHT) +'px';
 729                 }
 730                 function onCollect(){
 731                         elmContainer.removeChild( ELM_WRAPPER);
 732                         elmContainer = null;
 733                         FINDER_ICON_POOL.push( instansce);
 734                 }
 735
 736                 return {
 737                         init: function( _file, _elmContainer, _w, _index, _style, _callback){
 738                                 instansce = this;
 739                                 if( elmContainer !== _elmContainer){
 740                                         _elmContainer.appendChild( ELM_WRAPPER);
 741                                         elmContainer = _elmContainer;
 742                                 }
 743                                 if( file !== _file){
 744                                         file = _file;
 745                                         draw();
 746                                 }
 747                                 if( index !== _index){
 748                                         index = _index;
 749                                         resize();
 750                                 }
 751                                 callback = _callback;
 752                         },
 753                         elm: ELM_WRAPPER,
 754                         index: function( _index){
 755
 756                                 return index;
 757                         },
 758                         style: function( _style){
 759
 760                                 return style;
 761                         },
 762                         onResize: function( w){
 763
 764                         },
 765                         collect: function(){
 766                                 elmContainer.removeChild( ELM_WRAPPER);
 767                                 file = elmContainer = null;
 768                                 FINDER_ICON_POOL.push( this);
 769                         }
 770                 }
 771         }
 772         function updateIconPosition( _style, _w, _index, _elm){
 773
 774         }
 775         var BreadcrumbClass = function(){
 776                 var elmContainer,
 777                         ELM_WRAPPER = ELM_ORIGIN_FINDER_LOCATION_ITEM.cloneNode( true),
 778                         ELM_FILENAME = ELM_WRAPPER.getElementsByTagName( 'a')[0],
 779                         file, w, index, instansce,
 780                         callback;
 781                 ELM_WRAPPER.onclick = onClick;
 782                 function draw(){
 783                         ELM_FILENAME.className = 'file-icon-' +file.TYPE();
 784                         ELM_FILENAME.innerHTML = file.getName();
 785                 }
 786                 function resize( index){
 787                         ELM_WRAPPER.style.left = (index * 90) +'px';
 788                 }
 789                 function onClick(){
 790                         callback( index);
 791                 }
 792
 793                 return {
 794                         init: function( _file, _elmContainer, _index, _callback){
 795                                 instansce = this;
 796                                 if( elmContainer !== _elmContainer){
 797                                         _elmContainer.appendChild( ELM_WRAPPER);
 798                                         elmContainer = _elmContainer;
 799                                 }
 800                                 if( file !== _file){
 801                                         file = _file;
 802                                         draw();
 803                                 }
 804                                 if( index !== _index){
 805                                         index = _index;
 806                                         resize( index);
 807                                 }
 808                                 callback = _callback;
 809                         },
 810                         elm: ELM_WRAPPER,
 811                         index: function( _index){
 812
 813                                 return index;
 814                         },
 815                         onResize: function( w){
 816
 817                         },
 818                         collect: function(){
 819                                 elmContainer.removeChild( ELM_WRAPPER);
 820                                 file = elmContainer = null;
 821                                 BREAD_OBJECT_POOL.push( this);
 822                         }
 823                 }
 824         }
 825
 826         var FinderClass = function( ELM_CONTAINER, TREE_TYPE, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled){
 827                 var ICON_ARRAY = [],
 828                         BREAD_ARRAY = [],
 829                         elmContainer = ELM_ORIGIN_CONTAINER.cloneNode( true),
 830                         elmLocation = elmContainer.getElementsByTagName( 'ul')[0],
 831                         nodesDiv = elmContainer.getElementsByTagName( 'div'),
 832                         elmSidebarButton = nodesDiv[1],
 833                         elmStyleButton = nodesDiv[2],
 834                         elmActionButton = nodesDiv[3],
 835                         elmBody = nodesDiv[ nodesDiv.length -1],
 836                         tree = pettanr.file.createTree( TREE_TYPE),
 837                         headX,
 838                         headY,
 839                         headH = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON).height,
 840                         bodyY,
 841                         currentFile = null,
 842                         breadW = 90,
 843                         size = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON),
 844                         iconW = size.width,
 845                         iconH = size.height,
 846                         style = 0;
 847                         w = 800;
 848
 849                 tree.addTreeEventListener( 'onTreeUpdate', draw);
 850
 851                 function draw(){
 852                         var     l = tree.hierarchy() +1,
 853                                 m = BREAD_ARRAY.length,
 854                                 _file, _bread;
 855                         for(var i=0; i<l; ++i){
 856                                 _file = i !== l-1 ? tree.getParentFileAt( i) : tree.getCurrentFile();
 857                                 if( i < m){
 858                                         BREAD_ARRAY[ i].init( _file, elmLocation, i, onHeadClick);
 859                                 } else {
 860                                         BREAD_ARRAY.push( getBreadcrumb( _file, elmLocation, i, onHeadClick));
 861                                 }
 862                         }
 863                         while( l < BREAD_ARRAY.length){
 864                                 BREAD_ARRAY.pop().collect();
 865                         }
 866
 867                         l = _file.getChildFileLength();
 868                         m = ICON_ARRAY.length;
 869
 870                         for( i=0; i<l; ++i){
 871                                 if( i < m){
 872                                         ICON_ARRAY[ i].init( _file.getChildFileByIndex( i), elmBody, w, i, style, onBodyClick);
 873                                 } else {
 874                                         ICON_ARRAY.push( getFinderIcon( _file.getChildFileByIndex( i), elmBody, w, i, style, onBodyClick));
 875                                 }
 876                         }
 877                         while( l < ICON_ARRAY.length){
 878                                 ICON_ARRAY.pop().collect();
 879                         }
 880                 }
 881                 function onHeadClick( i){
 882                         var l = BREAD_ARRAY.length -1;
 883                         if( i < l){
 884                                 var _file = tree.getParentFileAt( i);
 885                                 if( _file !== null){
 886                                         tree.up( i);
 887                                         draw();
 888                                 }
 889                         }
 890                 }
 891                 function onBodyClick( i){
 892                         var l = ICON_ARRAY.length;
 893                         if( i < l){
 894                                 var _file = tree.getCurrentFile().getChildFileByIndex( i);
 895                                 if( _file !== null && _file.TYPE() === pettanr.file.FILE_TYPE_IS_FOLDER){
 896                                         tree.down( i);
 897                                         draw();
 898                                 }
 899                         }
 900                 }
 901
 902                 return {
 903                         init: function(){
 904                                 ELM_CONTAINER.appendChild( elmContainer);
 905                                 //$( elmLocation).click( onHeadClick);
 906                                 //$( elmContainer).click( onBodyClick);
 907                                 var position = pettanr.util.getAbsolutePosition( elmLocation);
 908                                 headX = position.x;
 909                                 headY = position.y;
 910                                 bodyY = pettanr.util.getAbsolutePosition( elmBody).y;
 911                                 delete this.init;
 912                         },
 913                         onOpen: function(){
 914                                 this.init !== undefined && this.init();
 915                                 draw();
 916                         },
 917                         onClose: function(){
 918
 919                         },
 920                         onWindowResize: function( _w, _h){
 921
 922                         }
 923                 }
 924         }
 925         function getFinderIcon( _file, _elmContainer, w, index, style, callback){
 926                 var _icon;
 927                 if( FINDER_ICON_POOL.length > 0){
 928                         _icon = FINDER_ICON_POOL.shift();
 929                 } else {
 930                         _icon = new FinderIconClass();
 931                 }
 932                 _icon.init( _file, _elmContainer, w, index, style, callback);
 933                 return _icon;
 934         }
 935
 936         function getBreadcrumb( _file, _elmContainer, index, callback){
 937                 var _bread;
 938                 if( BREAD_OBJECT_POOL.length > 0){
 939                         _bread = BREAD_OBJECT_POOL.shift();
 940                 } else {
 941                         _bread = new BreadcrumbClass();
 942                 }
 943                 _bread.init( _file, _elmContainer, index, callback);
 944                 return _bread;
 945         }
 946
 947         return {
 948                 init: function(){
 949
 950                 },
 951                 createFinder: function( _elmTarget, _treeType, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled){
 952                         var _finder = new FinderClass( _elmTarget, _treeType, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled);
 953                         FINDER_ARRAY.push( _finder);
 954                         return _finder;
 955                 }
 956         }
 957 })();
 958
 959 pettanr.gallery = ( function(){
 960         var finder,
 961                 elmContainer = document.getElementById( 'gallery'),
 962                 option;
 963
 964         return {
 965                 init: function( _option){
 966                         option = _option;
 967                         delete pettanr.gallery.init;
 968                 },
 969                 firstOpen: function(){
 970                         finder = pettanr.finder.createFinder( elmContainer, pettanr.file.TREE_TYPE_IS_IMAGE);
 971                         delete pettanr.gallery.firstOpen;
 972                 },
 973                 onOpen: function(){
 974                         pettanr.gallery.firstOpen !== undefined && pettanr.gallery.firstOpen();
 975                         finder.onOpen();
 976
 977                 },
 978                 onClose: function(){
 979                         finder.onClose();
 980                 },
 981                 onWindowResize: function( _w, _h){
 982                         finder.onWindowResize( _w, _h);
 983                 }
 984         }
 985 })();
 986
 987 pettanr.cabinet = ( function(){
 988         var finder,
 989                 elmContainer = document.getElementById( 'cabinet'),
 990                 option;
 991
 992         return {
 993                 init: function( _option){
 994                         option = _option;
 995                         delete pettanr.cabinet.init;
 996                 },
 997                 firstOpen: function(){
 998                         finder = pettanr.finder.createFinder( elmContainer, pettanr.file.TREE_TYPE_IS_COMIC);
 999                         delete pettanr.cabinet.firstOpen;
1000                 },
1001                 onOpen: function(){
1002                         pettanr.cabinet.firstOpen !== undefined && pettanr.cabinet.firstOpen();
1003                         finder.onOpen();
1004
1005                 },
1006                 onClose: function(){
1007                         finder.onClose();
1008                 },
1009                 onWindowResize: function( _w, _h){
1010                         finder.onWindowResize( _w, _h);
1011                 }
1012         }
1013 })();
1014
1015 // i18n
1016 // login
1017 // lib
1018
1019 pettanr.fn( pettanr.view);
1020 pettanr.fn( pettanr.overlay);
1021 pettanr.fn( pettanr.key);
1022 pettanr.fn( pettanr.balloon);
1023 pettanr.fn( pettanr.editor);
1024 pettanr.fn( pettanr.file);
1025 pettanr.fn( pettanr.finder);
1026 pettanr.fn( pettanr.gallery);
1027 pettanr.fn( pettanr.cabinet);
1028
1029 $(window).ready( pettanr.init);