0.4.x/javascripts/system.js

   1 /*
   2  * pettanR system.js
   3  *   version 0.4.2
   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 = [],                  // store all of fileData( json object )
  70                 FILEDATA_HAS_domainID_RESISTER = {},
  71                 FILEDATA_ACCESS = [],                   // file operations for Kernel only ! hide from Out of pettanr.file
  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 || null;
 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.DATA.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                                 _reaourceID = buildDomainID( _data.json, _childType);
 282
 283                         for(var i=0; i<l; ++i){
 284                                 _newData = buildFileData( _json[ i], _data.json, _data, _childType);
 285
 286                                 if( _reaourceID !== null){
 287                                         _rFolderData = getDomainFolder( _reaourceID, _childType, _file);
 288                                         _rFolderData.children.push( _newData);
 289                                 }
 290                                 if( _newData.artist){
 291                                         _artistFolderData = _artistFolderData || getDomainFolder( buildDomainID( _data.json, 'artist'), 'Artists', _file);
 292                                         _artistFolder = _artistFolder || new FileClass( SYSTEM_TREE, _file, _artistFolderData);
 293                                         _rFolderData = getDomainFolder( buildDomainID( _artistFolderData.rID, '' +_newData.artist.id), _newData.artist.name, _artistFolder);
 294                                         _rFolderData.children.push( _newData);
 295                                 }
 296                                 if( _newData.comic){
 297                                         _comicFolderData = _comicFolderData || getDomainFolder( buildDomainID( _data.json, 'comic'), 'Comics', _file);
 298                                         _comicFolder = _comicFolder || new FileClass( SYSTEM_TREE, _file, _comicFolderData);
 299                                         _rFolderData = getDomainFolder( buildDomainID( _comicFolderData.rID, '' +_newData.comic.id), _newData.comic.title, _comicFolder);
 300                                         _rFolderData.children.push( _newData);
 301                                 }
 302                                 if( _newData.author){
 303                                         _authorFolderData = _authorFolderData || getDomainFolder( buildDomainID( _data.json, 'author'), 'Author', _file);
 304                                         _authorFolder = _authorFolder || new FileClass( SYSTEM_TREE, _file, _authorFolderData);
 305                                         _rFolderData = getDomainFolder( buildDomainID( _authorFolderData.rID, '' +_newData.author.id), _newData.author.name, _authorFolder);
 306                                         _rFolderData.children.push( _newData);
 307                                 }
 308                         }
 309                         delete _data.json;
 310                         _artistFolder && _artistFolder.collect();
 311                         _comicFolder && _comicFolder.collect();
 312                         _authorFolder && _authorFolder.collect();
 313                         _access.fileEventChatcher( new FileEventClass( FILE_EVENT_GET_SEQENTIAL_FILES, _file, 'children', null));
 314                 }
 315                 function onErrorJson( _file){
 316                         var _access = getFileDataAccess( _file),
 317                                 _data = _access !== null ? _access.DATA : null;
 318                         if( _data !== null){
 319                                 _data.state = FILE_STATE_IS_ERROR;
 320                         }
 321                 }
 322                 function buildFileData( _data, _url, _parent, _type){
 323                         _data.type = _type;
 324
 325                         if( _type === FILE_TYPE_IS_PANEL){
 326                                 _data.comicFileData = _parent;
 327                         }
 328
 329                         FILEDATA_RESITER.push( _data);
 330
 331                         return _data;
 332                 }
 333                 function buildDomainID( _url, _type){
 334                         if( !_url) return null;
 335                         var _typeStr = null;
 336
 337                         if( typeof _type !== 'number'){
 338                                 _typeStr = _type
 339                         } else
 340                         if( _type === FILE_TYPE_IS_IMAGE){
 341                                 _typeStr = 'image';
 342                         } else
 343                         if( _type === FILE_TYPE_IS_COMIC){
 344                                 _typeStr = 'comic';
 345                         }
 346                         if( _type === FILE_TYPE_IS_PANEL){
 347                                 _typeStr = 'panel';
 348                         }
 349                         if( _typeStr === null) return null;
 350
 351                         return [ _url.replace(/https?:\/\/([^\/]*).*/, '$1'), _typeStr].join('_');
 352                 }
 353         /**
 354          * getFileByResourceID( _domainID, opt_name, opt_folder)
 355          * opt 指定で 新しいフォルダの作成
 356          * rID を持つ Object は {} にも格納．
 357          */
 358                 function getDomainFolder( _domainID, opt_name, opt_folder){
 359                         if( FILEDATA_HAS_domainID_RESISTER[ _domainID]){
 360                                 return FILEDATA_HAS_domainID_RESISTER[ _domainID];
 361                         }
 362                         if( !opt_name && !opt_folder) return;
 363
 364                         var _fileName;
 365
 366                         if( typeof opt_name === 'string'){
 367                                 _fileName = opt_name;
 368                         } else
 369                         if( opt_name === FILE_TYPE_IS_IMAGE){
 370                                 _fileName = 'Pictures';
 371                         } else
 372                         if( opt_name === FILE_TYPE_IS_COMIC){
 373                                 _fileName = 'Comics';
 374                         } else
 375                         if( opt_name === FILE_TYPE_IS_PANEL){
 376                                 _fileName = 'Panels';
 377                         } else {
 378                                 _fileName = typeof opt_name;
 379                         }
 380
 381                         var _newData = {
 382                                 name:           _fileName,
 383                                 type:           FILE_TYPE_IS_FOLDER,
 384                                 rID:            _domainID,
 385                                 children:       []
 386                         };
 387                         FILEDATA_RESITER.push( _newData);
 388                         FILEDATA_HAS_domainID_RESISTER[ _domainID] = _newData;
 389
 390                         if( opt_folder && opt_folder.isChildFile( _newData) === false){
 391                                 var _access = getFileDataAccess( opt_folder),
 392                                         _data = _access !== null ? _access.DATA : null;
 393                                 _access === null && alert( _domainID)
 394                                 if( _data !== null){
 395                                         _data.children.push( _newData);
 396                                 }
 397                         }
 398
 399                         return _newData;
 400                 }
 401
 402                 function destroyTree(){
 403
 404                 }
 405
 406                 return {
 407                         init: function(){
 408                                 instance = this;
 409                                 delete FILE_CONTROLER.init;
 410                         },
 411                         createTree: function( _rootFileData){
 412                                 var _tree = new TreeClass( _rootFileData);
 413                                 _tree.init();
 414                                 TREE_ARRAY.push( _tree);
 415                                 return _tree;
 416                         },
 417                         getFileData: function( _file){
 418                                 var _access = getFileDataAccess( _file);
 419                                 return _access !== null ? _access.DATA : null;
 420                         },
 421                         getUID: function ( _filedata){
 422                                 var l = FILEDATA_RESITER.length;
 423                                 for( var i=0; i<l; ++i){
 424                                         if( FILEDATA_RESITER[ i] === _filedata) return i;
 425                                 }
 426                                 return -1;
 427                         },
 428                         getSeqentialFiles: function( _file){
 429                                 var _data = this.getFileData( _file),
 430                                         _json = _data ? _data.json : null;
 431                                 if( _json !== null){
 432                                         REQUEST_CONTROLER.getJson( _file, _json, onLoadJson, onErrorJson);
 433                                 }
 434                         },
 435                         updateFileAttribute: function( _uid, key, _value, _opt_callback){
 436                                 var _data = getFileDataAccess( _uid),
 437                                         _type = _data.TYPE;
 438
 439                         },
 440                         getFileAttribute: function( _uid, KEYorKEYARRAY){
 441                                 var _fileData = getFileDataAccess( _uid),
 442                                         _type = _fileData.TYPE;
 443                         },
 444                         move: function( _prentUID, _targetfile, _newFolder, _newIndex, _opt_callback){
 445                                 var _parentData = getFileDataAccess( _prentUID),
 446                                         _parentType = _parentData.TYPE,
 447                                         _targetData = getFileDataAccess( _targetfile),
 448                                         _targetType = _targetData.TYPE;
 449                         },
 450                         replace: function( _uid, _file, _newIndex){
 451
 452                         },
 453                         fileEventRellay: function( _targetFile, _targetTree, _event){
 454                                 var _uid = _targetTree.getUID(),
 455                                         _access = TREE_ACCESS_ARRAY[ _uid],
 456                                         l = TREE_ARRAY.length,
 457                                         _tree, _currentFile;
 458                                 _access !== undefined && _access.fileEventChatcher( _event);
 459                                 for(var i=0; i<l; ++i){
 460                                         if( i !== _uid){
 461                                                 _tree = TREE_ARRAY[i];
 462                                                 _currentFile = _tree.getCurrentFile();
 463                                                 if( FILE_CONTROLER.getFileData( _currentFile) === _access.DATA){
 464                                                         _tree.fileEventChatcher( _event);
 465                                                 }
 466                                         }
 467                                 }
 468                         }
 469                 }
 470         })();
 471
 472         var FileEventTicketClass = function( UID, _eventType, _callback){
 473                 return {
 474                         fileUID:        UID,
 475                         eventType:      _eventType,
 476                         callBack:       _callback,
 477                         destroy: function(){
 478                                 this.callBack = _callback = null;
 479                         }
 480                 }
 481         }
 482
 483         var FileEventClass = function( eventType, file, key, value){
 484                 return {
 485                         eventType:                      eventType,
 486                         targetFile:                     file,
 487                         updatedAttribute:       key,
 488                         updatedValue:           value
 489                 }
 490         }
 491
 492 /*
 493  * fileのdataはobjectで保持している。
 494  * pettanr.file.の外からファイルをみるときは、FileClassを通して操作する。
 495  * fileの変更、それに付随して追加されたイベントは、TreeClassで管理される。
 496  * treeがdestryされると、fileのイベントリスナーも全て削除される。
 497  * 他の tree も data の共通する currentFile に対してのみは、file の変更イベントを受け取って流す．
 498  */
 499
 500         var FileClass = function( TREE, parentFile, data){
 501                 if( !data.children){
 502                         data.children = [];
 503                 }
 504                 var TYPE = data.type,
 505                         name = data.name || null,
 506                         thumbnail = null,
 507                         uid = FILE_CONTROLER.getUID( data),
 508                         CHILDREN = data.children,
 509                         instance;
 510
 511                 if( uid === -1){
 512                         //alert( 'invalid uid');
 513                         uid = FILEDATA_RESITER.length;
 514                         FILEDATA_RESITER.push( data);
 515                 }
 516
 517                 FILEDATA_ACCESS.push(
 518                         {
 519                                 TYPE:                           TYPE,
 520                                 DATA:                           data,
 521                                 destroy:                        destroy,
 522                                 updateParent:           updateParent,
 523                                 fileEventChatcher:      dispatchEvent
 524                         }
 525                 );
 526                 function destroy(){
 527                         name = thumbnail = parentFile = data = CHILDREN = null;
 528
 529                 }
 530                 function updateParent( _parent){
 531                         parentFile = _parent;
 532                 }
 533                 function dispatchEvent( e){
 534                         FILE_CONTROLER.fileEventRellay( instance, TREE, e);
 535                 }
 536                 return {
 537                         init: function(){
 538                                 instance = this;
 539                                 delete this.init;
 540                         },
 541                         TYPE: function(){ return TYPE;},
 542                         getName: function(){
 543                                 if( name !== null) return name;
 544                                 if( data.name){
 545                                         return data.name;
 546                                 }
 547                                 if( TYPE === FILE_TYPE_IS_IMAGE){
 548                                         name = [ data.id, data.ext].join( '.');
 549                                 } else
 550                                 if( TYPE === FILE_TYPE_IS_PANEL){
 551                                         name = data.comic.title + ' | ' +data.t;
 552                                 }
 553                                 return name || 'no_name';
 554                         },
 555                         getThumbnail: function(){
 556                                 if( thumbnail !== null) return thumbnail;
 557                                 if( TYPE === FILE_TYPE_IS_IMAGE){
 558                                         thumbnail = [ 'thumbnail/', data.id, '.', data.ext].join( '');
 559                                 }
 560                                 return thumbnail || null;
 561                         },
 562                         getUID: function(){
 563                                 return uid;
 564                         },
 565                         getState: function(){
 566                                 return data.state !== undefined ? data.state : FILE_STATE_IS_OK;
 567                         },
 568                         getChildFileLength: function(){
 569                                 return CHILDREN && typeof CHILDREN.length === 'number' ? CHILDREN.length : 0;
 570                         },
 571                         getChildFileByIndex: function( _index){
 572                                 if( typeof _index !== 'number' || _index < 0 || typeof CHILDREN.length !== 'number' || _index >= CHILDREN.length) return null;
 573                                 _file = new FileClass( TREE, this, CHILDREN[ _index]);
 574                                 _file.init();
 575                                 return _file;
 576                         },
 577                         getChildFileIndex: function( _FILEorFILEDATA){
 578                                 if( !CHILDREN || typeof CHILDREN.length !== 'number') return -1;
 579                                 var l = CHILDREN.length,
 580                                         _fileData = FILE_CONTROLER.getFileData( _FILEorFILEDATA);
 581                                 if( _fileData === null) return -1;
 582                                 for(var i=0; i<l; ++i){
 583                                         if( CHILDREN[ i] === _fileData) return i;
 584                                 }
 585                                 return -1;
 586                         },
 587                         isChildFile: function( _FILEorFILEDATA){
 588                                 return this.getChildFileIndex( _FILEorFILEDATA) !== -1;
 589                         },
 590                         getAttribute: function( KEYorKEYARRAY){
 591                                 return FILE_CONTROLER.getFileAttribute( UID, KEYorKEYARRAY);
 592                         },
 593                         getSeqentialFiles: function(){
 594                                 FILE_CONTROLER.getSeqentialFiles( this);
 595                         },
 596                         updateAttribute: function( key, value, opt_callback){
 597                                 TREE.updateFileAttribute( UID, key, value, opt_callback);
 598                         },
 599                         move: function( _newFolder, _newIndex, opt_callback){
 600                                 TREE.move( parentFile, UID, _newFolder, _newIndex, opt_callback);
 601                         },
 602                         replace: function( _newIndex, opt_callback){
 603                                 TREE.replace( parentFile, UID, _newIndex, opt_callback);
 604                         },
 605                         addEventListener: function( _eventType, _callback){
 606                                 FILE_CONTROLER.addEventListener( UID, _eventType, _callback);
 607                         },
 608                         removeEventListener: function( _eventType, _callback){
 609                                 FILE_CONTROLER.removeEventListener( UID, _eventType, _callback);
 610                         },
 611                         collect: function(){
 612
 613                         }
 614                 }
 615         };
 616         function getFileObject( TREE, parentFile, data){
 617                 var _file;
 618                 if( FILE_OBJECT_POOL.length > 0){
 619                         _file = FILE_OBJECT_POOL.shift();
 620                 } else {
 621                         _file = new FileClass();
 622                 }
 623                 _file.init( TREE, parentFile, data);
 624                 return _file;
 625         }
 626
 627         var ROOT_FILEDATA = {
 628                         name:           'root',
 629                         type:           FILE_TYPE_IS_FOLDER,
 630                         children:       []
 631                 },
 632                 IMAGE_FILEDATA = {
 633                         name:           'image root',
 634                         type:           FILE_TYPE_IS_FOLDER,
 635                         json:           pettanr.CONST.URL_ORIGINAL_PICTURES_JSON,
 636                         children:       [
 637                                 {
 638                                         name:           'My Pictures',
 639                                         type:           FILE_TYPE_IS_FOLDER,
 640                                         children:       [],
 641                                         childType:      FILE_TYPE_IS_IMAGE
 642                                 }
 643                         ],
 644                         childType:      FILE_TYPE_IS_IMAGE
 645                 },
 646                 COMIC_FILEDATA = {
 647                         name:           'comic root',
 648                         type:           FILE_TYPE_IS_FOLDER,
 649                         json:           pettanr.CONST.URL_PANELS_JSON,
 650                         children:       [
 651                                 {
 652                                         name:           'My Comics',
 653                                         type:           FILE_TYPE_IS_FOLDER,
 654                                         children:       [],
 655                                         childType:      FILE_TYPE_IS_COMIC
 656                                 }
 657                         ],
 658                         childType:      FILE_TYPE_IS_PANEL
 659                 };
 660         //FILEDATA_RESITER.push( ROOT_FILEDATA, IMAGE_FILEDATA, IMAGE_FILEDATA.children[0], COMIC_FILEDATA);
 661         ROOT_FILEDATA.children.push( COMIC_FILEDATA, IMAGE_FILEDATA);
 662
 663         var SYSTEM_TREE = FILE_CONTROLER.createTree( ROOT_FILEDATA),
 664                 ROOT_FILE = SYSTEM_TREE.getRootFile(),
 665                 COMIC_ROOT_INDEX = ROOT_FILE.getChildFileIndex( COMIC_FILEDATA),
 666                 IMAGE_ROOT_INDEX = ROOT_FILE.getChildFileIndex( IMAGE_FILEDATA);
 667
 668         return {
 669                 init: function(){
 670                         REQUEST_CONTROLER.init();
 671                         FILE_CONTROLER.init();
 672                         delete pettanr.file.init;
 673                 },
 674                 createTree: function( _treeType){
 675                         var _rootFile;
 676                         if( _treeType === TREE_TYPE_IS_COMIC) _rootFile = COMIC_FILEDATA;
 677                         if( _treeType === TREE_TYPE_IS_IMAGE) _rootFile = IMAGE_FILEDATA;
 678                         if( !_rootFile) return null;
 679                         return FILE_CONTROLER.createTree( _rootFile);
 680                 },
 681                 TREE_TYPE_IS_COMIC:             1,
 682                 TREE_TYPE_IS_IMAGE:             2,
 683                 TREE_TYPE_IS_SETTING:   3,
 684                 FILE_TYPE_IS_FOLDER:    FILE_TYPE_IS_FOLDER,
 685                 FILE_TYPE_IS_IMAGE:             FILE_TYPE_IS_IMAGE,
 686                 FILE_TYPE_IS_PANEL:             FILE_TYPE_IS_PANEL,
 687                 FILE_TYPE_IS_SETTING:   FILE_TYPE_IS_SETTING
 688         }
 689 })();
 690
 691 pettanr.finder = ( function(){
 692         var FINDER_ARRAY = [],
 693                 ELM_ORIGIN_FINDER_LOCATION_ITEM = pettanr.util.pullHtmlAsTemplete( 'templete-finder-location-item'),
 694                 ELM_ORIGIN_FINDER_ICON = pettanr.util.pullHtmlAsTemplete( 'templete-finder-icon'),
 695                 ELM_ORIGIN_CONTAINER = pettanr.util.pullHtmlAsTemplete( 'templete-finder-container'),
 696                 ICON_HEIGHT = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON).height,
 697                 ICON_CLASSNAME = ELM_ORIGIN_FINDER_ICON.getElementsByTagName( 'div')[0].className,
 698                 FINDER_ICON_POOL = [],
 699                 BREAD_OBJECT_POOL = [];
 700
 701         var FinderIconClass = function(){
 702                 var elmContainer,
 703                         ELM_WRAPPER = ELM_ORIGIN_FINDER_ICON.cloneNode( true),
 704                         ELM_THUMBNAIL = pettanr.util.getElementsByClassName( ELM_WRAPPER, 'finder-icon-thumbnail', 'div')[0],
 705                         ELM_FILENAME = pettanr.util.getElementsByClassName( ELM_WRAPPER, 'finder-icon-filename', 'div')[0],
 706                         file, w, index, style, instansce, callback;
 707
 708                 ELM_WRAPPER.onclick = onClick;
 709                 function onClick(){
 710                         callback( index);
 711                 }
 712
 713                 function draw(){
 714                         var _thumb = file.getThumbnail();
 715                         if( _thumb !== null){
 716                                 ELM_THUMBNAIL.className = ICON_CLASSNAME + ' has-thumbnail';
 717                                 ELM_THUMBNAIL.style.backgroundImage = [ 'url(', _thumb, ')'].join( '');
 718                         } else {
 719                                 ELM_THUMBNAIL.className = ICON_CLASSNAME + ' file-type-' +file.TYPE();
 720                                 ELM_THUMBNAIL.style.backgroundImage = '';
 721                         }
 722                         ELM_FILENAME.innerHTML = file.getName();
 723                 }
 724                 function resize(){
 725                         ELM_WRAPPER.style.top = (index * ICON_HEIGHT) +'px';
 726                 }
 727                 function onCollect(){
 728                         elmContainer.removeChild( ELM_WRAPPER);
 729                         elmContainer = null;
 730                         FINDER_ICON_POOL.push( instansce);
 731                 }
 732
 733                 return {
 734                         init: function( _file, _elmContainer, _w, _index, _style, _callback){
 735                                 instansce = this;
 736                                 if( elmContainer !== _elmContainer){
 737                                         _elmContainer.appendChild( ELM_WRAPPER);
 738                                         elmContainer = _elmContainer;
 739                                 }
 740                                 if( file !== _file){
 741                                         file = _file;
 742                                         draw();
 743                                 }
 744                                 if( index !== _index){
 745                                         index = _index;
 746                                         resize();
 747                                 }
 748                                 callback = _callback;
 749                         },
 750                         elm: ELM_WRAPPER,
 751                         index: function( _index){
 752
 753                                 return index;
 754                         },
 755                         style: function( _style){
 756
 757                                 return style;
 758                         },
 759                         onResize: function( w){
 760
 761                         },
 762                         collect: function(){
 763                                 elmContainer.removeChild( ELM_WRAPPER);
 764                                 file = elmContainer = null;
 765                                 FINDER_ICON_POOL.push( instansce);
 766                         }
 767                 }
 768         }
 769         function updateIconPosition( _style, _w, _index, _elm){
 770
 771         }
 772         var BreadcrumbClass = function(){
 773                 var elmContainer,
 774                         ELM_WRAPPER = ELM_ORIGIN_FINDER_LOCATION_ITEM.cloneNode( true),
 775                         ELM_FILENAME = ELM_WRAPPER.getElementsByTagName( 'a')[0],
 776                         file, w, index, instansce,
 777                         callback;
 778                 ELM_WRAPPER.onclick = onClick;
 779                 function draw(){
 780                         ELM_FILENAME.className = 'file-icon-' +file.TYPE();
 781                         ELM_FILENAME.innerHTML = file.getName();
 782                 }
 783                 function resize( index){
 784                         ELM_WRAPPER.style.left = (index * 90) +'px';
 785                 }
 786                 function onClick(){
 787                         callback( index);
 788                 }
 789
 790                 return {
 791                         init: function( _file, _elmContainer, _index, _callback){
 792                                 instansce = this;
 793                                 if( elmContainer !== _elmContainer){
 794                                         _elmContainer.appendChild( ELM_WRAPPER);
 795                                         elmContainer = _elmContainer;
 796                                 }
 797                                 if( file !== _file){
 798                                         file = _file;
 799                                         draw();
 800                                 }
 801                                 if( index !== _index){
 802                                         index = _index;
 803                                         resize( index);
 804                                 }
 805                                 callback = _callback;
 806                         },
 807                         elm: ELM_WRAPPER,
 808                         index: function( _index){
 809
 810                                 return index;
 811                         },
 812                         onResize: function( w){
 813
 814                         },
 815                         collect: function(){
 816                                 elmContainer.removeChild( ELM_WRAPPER);
 817                                 file = elmContainer = null;
 818                                 BREAD_OBJECT_POOL.push( this);
 819                         }
 820                 }
 821         }
 822
 823         var FinderClass = function( ELM_CONTAINER, TREE_TYPE, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled){
 824                 var ICON_ARRAY = [],
 825                         BREAD_ARRAY = [],
 826                         elmContainer = ELM_ORIGIN_CONTAINER.cloneNode( true),
 827                         elmLocation = elmContainer.getElementsByTagName( 'ul')[0],
 828                         nodesDiv = elmContainer.getElementsByTagName( 'div'),
 829                         elmSidebarButton = nodesDiv[1],
 830                         elmStyleButton = nodesDiv[2],
 831                         elmActionButton = nodesDiv[3],
 832                         elmBody = nodesDiv[ nodesDiv.length -1],
 833                         tree = pettanr.file.createTree( TREE_TYPE),
 834                         headX,
 835                         headY,
 836                         headH = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON).height,
 837                         bodyY,
 838                         currentFile = null,
 839                         breadW = 90,
 840                         size = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON),
 841                         iconW = size.width,
 842                         iconH = size.height,
 843                         style = 0;
 844                         w = 800;
 845
 846                 tree.addTreeEventListener( 'onTreeUpdate', draw);
 847
 848                 function draw(){
 849                         var     l = tree.hierarchy() +1,
 850                                 m = BREAD_ARRAY.length,
 851                                 _file, _bread;
 852                         for(var i=0; i<l; ++i){
 853                                 _file = i !== l-1 ? tree.getParentFileAt( i) : tree.getCurrentFile();
 854                                 if( i < m){
 855                                         BREAD_ARRAY[ i].init( _file, elmLocation, i, onHeadClick);
 856                                 } else {
 857                                         BREAD_ARRAY.push( getBreadcrumb( _file, elmLocation, i, onHeadClick));
 858                                 }
 859                         }
 860                         while( l < BREAD_ARRAY.length){
 861                                 BREAD_ARRAY.pop().collect();
 862                         }
 863
 864                         l = _file.getChildFileLength();
 865                         m = ICON_ARRAY.length;
 866
 867                         for( i=0; i<l; ++i){
 868                                 if( i < m){
 869                                         ICON_ARRAY[ i].init( _file.getChildFileByIndex( i), elmBody, w, i, style, onBodyClick);
 870                                 } else {
 871                                         ICON_ARRAY.push( getFinderIcon( _file.getChildFileByIndex( i), elmBody, w, i, style, onBodyClick));
 872                                 }
 873                         }
 874                         while( l < ICON_ARRAY.length){
 875                                 ICON_ARRAY.pop().collect();
 876                         }
 877                 }
 878                 function onHeadClick( i){
 879                         var l = BREAD_ARRAY.length -1;
 880                         if( i < l){
 881                                 var _file = tree.getParentFileAt( i);
 882                                 if( _file !== null){
 883                                         tree.up( i);
 884                                         draw();
 885                                 }
 886                         }
 887                 }
 888                 function onBodyClick( i){
 889                         var l = ICON_ARRAY.length;
 890                         if( i < l){
 891                                 var _file = tree.getCurrentFile().getChildFileByIndex( i);
 892                                 if( _file !== null && _file.TYPE() === pettanr.file.FILE_TYPE_IS_FOLDER){
 893                                         tree.down( i);
 894                                         draw();
 895                                 }
 896                         }
 897                 }
 898
 899                 return {
 900                         init: function(){
 901                                 ELM_CONTAINER.appendChild( elmContainer);
 902                                 //$( elmLocation).click( onHeadClick);
 903                                 //$( elmContainer).click( onBodyClick);
 904                                 var position = pettanr.util.getAbsolutePosition( elmLocation);
 905                                 headX = position.x;
 906                                 headY = position.y;
 907                                 bodyY = pettanr.util.getAbsolutePosition( elmBody).y;
 908                                 delete this.init;
 909                         },
 910                         onOpen: function(){
 911                                 this.init !== undefined && this.init();
 912                                 draw();
 913                         },
 914                         onClose: function(){
 915
 916                         },
 917                         onWindowResize: function( _w, _h){
 918
 919                         }
 920                 }
 921         }
 922         function getFinderIcon( _file, _elmContainer, w, index, style, callback){
 923                 var _icon;
 924                 if( FINDER_ICON_POOL.length > 0){
 925                         _icon = FINDER_ICON_POOL.shift();
 926                 } else {
 927                         _icon = new FinderIconClass();
 928                 }
 929                 _icon.init( _file, _elmContainer, w, index, style, callback);
 930                 return _icon;
 931         }
 932
 933         function getBreadcrumb( _file, _elmContainer, index, callback){
 934                 var _bread;
 935                 if( BREAD_OBJECT_POOL.length > 0){
 936                         _bread = BREAD_OBJECT_POOL.shift();
 937                 } else {
 938                         _bread = new BreadcrumbClass();
 939                 }
 940                 _bread.init( _file, _elmContainer, index, callback);
 941                 return _bread;
 942         }
 943
 944         return {
 945                 init: function(){
 946
 947                 },
 948                 createFinder: function( _elmTarget, _treeType, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled){
 949                         var _finder = new FinderClass( _elmTarget, _treeType, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled);
 950                         FINDER_ARRAY.push( _finder);
 951                         return _finder;
 952                 }
 953         }
 954 })();
 955
 956 pettanr.gallery = ( function(){
 957         var finder,
 958                 elmContainer = document.getElementById( 'gallery'),
 959                 option;
 960
 961         return {
 962                 init: function( _option){
 963                         option = _option;
 964                         delete pettanr.gallery.init;
 965                 },
 966                 firstOpen: function(){
 967                         finder = pettanr.finder.createFinder( elmContainer, pettanr.file.TREE_TYPE_IS_IMAGE);
 968                         delete pettanr.gallery.firstOpen;
 969                 },
 970                 onOpen: function(){
 971                         pettanr.gallery.firstOpen !== undefined && pettanr.gallery.firstOpen();
 972                         finder.onOpen();
 973
 974                 },
 975                 onClose: function(){
 976                         finder.onClose();
 977                 },
 978                 onWindowResize: function( _w, _h){
 979                         finder.onWindowResize( _w, _h);
 980                 }
 981         }
 982 })();
 983
 984 pettanr.cabinet = ( function(){
 985         var finder,
 986                 elmContainer = document.getElementById( 'cabinet'),
 987                 option;
 988
 989         return {
 990                 init: function( _option){
 991                         option = _option;
 992                         delete pettanr.cabinet.init;
 993                 },
 994                 firstOpen: function(){
 995                         finder = pettanr.finder.createFinder( elmContainer, pettanr.file.TREE_TYPE_IS_COMIC);
 996                         delete pettanr.cabinet.firstOpen;
 997                 },
 998                 onOpen: function(){
 999                         pettanr.cabinet.firstOpen !== undefined && pettanr.cabinet.firstOpen();
1000                         finder.onOpen();
1001
1002                 },
1003                 onClose: function(){
1004                         finder.onClose();
1005                 },
1006                 onWindowResize: function( _w, _h){
1007                         finder.onWindowResize( _w, _h);
1008                 }
1009         }
1010 })();
1011
1012 // i18n
1013 // login
1014 // lib
1015
1016 pettanr.fn( pettanr.view);
1017 pettanr.fn( pettanr.overlay);
1018 pettanr.fn( pettanr.key);
1019 pettanr.fn( pettanr.balloon);
1020 pettanr.fn( pettanr.editor);
1021 pettanr.fn( pettanr.file);
1022 pettanr.fn( pettanr.finder);
1023 pettanr.fn( pettanr.gallery);
1024 pettanr.fn( pettanr.cabinet);
1025
1026 $(window).ready( pettanr.init);