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 = [],
  70                 FILEDATA_HAS_domainID_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                                 _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                                 CHILDREN:                       CHILDREN,
 522                                 destroy:                        destroy,
 523                                 updateParent:           updateParent,
 524                                 fileEventChatcher:      dispatchEvent
 525                         }
 526                 );
 527                 function destroy(){
 528                         name = thumbnail = parentFile = data = CHILDREN = null;
 529
 530                 }
 531                 function updateParent( _parent){
 532                         parentFile = _parent;
 533                 }
 534                 function dispatchEvent( e){
 535                         FILE_CONTROLER.fileEventRellay( instance, TREE, e);
 536                 }
 537                 return {
 538                         init: function(){
 539                                 instance = this;
 540                                 delete this.init;
 541                         },
 542                         TYPE: function(){ return TYPE;},
 543                         getName: function(){
 544                                 if( name !== null) return name;
 545                                 if( data.name){
 546                                         return data.name;
 547                                 }
 548                                 if( TYPE === FILE_TYPE_IS_IMAGE){
 549                                         name = [ data.id, data.ext].join( '.');
 550                                 } else
 551                                 if( TYPE === FILE_TYPE_IS_PANEL){
 552                                         name = data.comic.title + ' | ' +data.t;
 553                                 }
 554                                 return name || 'no_name';
 555                         },
 556                         getThumbnail: function(){
 557                                 if( thumbnail !== null) return thumbnail;
 558                                 if( TYPE === FILE_TYPE_IS_IMAGE){
 559                                         thumbnail = [ 'thumbnail/', data.id, '.', data.ext].join( '');
 560                                 }
 561                                 return thumbnail || null;
 562                         },
 563                         getUID: function(){
 564                                 return uid;
 565                         },
 566                         getState: function(){
 567                                 return data.state !== undefined ? data.state : FILE_STATE_IS_OK;
 568                         },
 569                         getChildFileLength: function(){
 570                                 return CHILDREN && typeof CHILDREN.length === 'number' ? CHILDREN.length : 0;
 571                         },
 572                         getChildFileByIndex: function( _index){
 573                                 if( typeof _index !== 'number' || _index < 0 || typeof CHILDREN.length !== 'number' || _index >= CHILDREN.length) return null;
 574                                 _file = new FileClass( TREE, this, CHILDREN[ _index]);
 575                                 _file.init();
 576                                 return _file;
 577                         },
 578                         getChildFileIndex: function( _FILEorFILEDATA){
 579                                 if( !CHILDREN || typeof CHILDREN.length !== 'number') return -1;
 580                                 var l = FILEDATA_RESITER.length,
 581                                         _fileData = null;
 582                                 for( var i=0; i<l; ++i){
 583                                         if( _FILEorFILEDATA === FILEDATA_RESITER[ i]){
 584                                                 _fileData = _FILEorFILEDATA;
 585                                                 break;
 586                                         };
 587                                 }
 588                                 if( _fileData === null){
 589                                         _fileData = FILE_CONTROLER.getFileData( _FILEorFILEDATA);
 590                                 }
 591                                 if( _fileData === null) return -1;
 592
 593                                 l = CHILDREN.length
 594                                 for( var i=0; i<l; ++i){
 595                                         if( CHILDREN[ i] === _fileData) return i;
 596                                 }
 597                                 return -1;
 598                         },
 599                         isChildFile: function( _FILEorFILEDATA){
 600                                 return this.getChildFileIndex( _FILEorFILEDATA) !== -1;
 601                         },
 602                         getAttribute: function( KEYorKEYARRAY){
 603                                 return FILE_CONTROLER.getFileAttribute( UID, KEYorKEYARRAY);
 604                         },
 605                         getSeqentialFiles: function(){
 606                                 FILE_CONTROLER.getSeqentialFiles( this);
 607                         },
 608                         updateAttribute: function( key, value, opt_callback){
 609                                 TREE.updateFileAttribute( UID, key, value, opt_callback);
 610                         },
 611                         move: function( _newFolder, _newIndex, opt_callback){
 612                                 TREE.move( parentFile, UID, _newFolder, _newIndex, opt_callback);
 613                         },
 614                         replace: function( _newIndex, opt_callback){
 615                                 TREE.replace( parentFile, UID, _newIndex, opt_callback);
 616                         },
 617                         addEventListener: function( _eventType, _callback){
 618                                 FILE_CONTROLER.addEventListener( UID, _eventType, _callback);
 619                         },
 620                         removeEventListener: function( _eventType, _callback){
 621                                 FILE_CONTROLER.removeEventListener( UID, _eventType, _callback);
 622                         },
 623                         collect: function(){
 624
 625                         }
 626                 }
 627         };
 628         function getFileObject( TREE, parentFile, data){
 629                 var _file;
 630                 if( FILE_OBJECT_POOL.length > 0){
 631                         _file = FILE_OBJECT_POOL.shift();
 632                 } else {
 633                         _file = new FileClass();
 634                 }
 635                 _file.init( TREE, parentFile, data);
 636                 return _file;
 637         }
 638
 639         var ROOT_FILEDATA = {
 640                         name:           'root',
 641                         type:           FILE_TYPE_IS_FOLDER,
 642                         children:       []
 643                 },
 644                 IMAGE_FILEDATA = {
 645                         name:           'image root',
 646                         type:           FILE_TYPE_IS_FOLDER,
 647                         json:           pettanr.CONST.URL_ORIGINAL_PICTURES_JSON,
 648                         children:       [
 649                                 {
 650                                         name:           'My Pictures',
 651                                         type:           FILE_TYPE_IS_FOLDER,
 652                                         children:       [],
 653                                         childType:      FILE_TYPE_IS_IMAGE
 654                                 }
 655                         ],
 656                         childType:      FILE_TYPE_IS_IMAGE
 657                 },
 658                 COMIC_FILEDATA = {
 659                         name:           'comic root',
 660                         type:           FILE_TYPE_IS_FOLDER,
 661                         json:           pettanr.CONST.URL_PANELS_JSON,
 662                         children:       [
 663                                 {
 664                                         name:           'My Comics',
 665                                         type:           FILE_TYPE_IS_FOLDER,
 666                                         children:       [],
 667                                         childType:      FILE_TYPE_IS_COMIC
 668                                 }
 669                         ],
 670                         childType:      FILE_TYPE_IS_PANEL
 671                 };
 672         //FILEDATA_RESITER.push( ROOT_FILEDATA, IMAGE_FILEDATA, IMAGE_FILEDATA.children[0], COMIC_FILEDATA);
 673         ROOT_FILEDATA.children.push( COMIC_FILEDATA, IMAGE_FILEDATA);
 674
 675         var SYSTEM_TREE = FILE_CONTROLER.createTree( ROOT_FILEDATA),
 676                 ROOT_FILE = SYSTEM_TREE.getRootFile(),
 677                 COMIC_ROOT_INDEX = ROOT_FILE.getChildFileIndex( COMIC_FILEDATA),
 678                 IMAGE_ROOT_INDEX = ROOT_FILE.getChildFileIndex( IMAGE_FILEDATA);
 679
 680         return {
 681                 init: function(){
 682                         REQUEST_CONTROLER.init();
 683                         FILE_CONTROLER.init();
 684                         delete pettanr.file.init;
 685                 },
 686                 createTree: function( _treeType){
 687                         var _rootFile;
 688                         if( _treeType === TREE_TYPE_IS_COMIC) _rootFile = COMIC_FILEDATA;
 689                         if( _treeType === TREE_TYPE_IS_IMAGE) _rootFile = IMAGE_FILEDATA;
 690                         if( _rootFile === undefined) return;
 691                         return FILE_CONTROLER.createTree( _rootFile);
 692                 },
 693                 TREE_TYPE_IS_COMIC:             1,
 694                 TREE_TYPE_IS_IMAGE:             2,
 695                 TREE_TYPE_IS_SETTING:   3,
 696                 FILE_TYPE_IS_FOLDER:    FILE_TYPE_IS_FOLDER,
 697                 FILE_TYPE_IS_IMAGE:             FILE_TYPE_IS_IMAGE,
 698                 FILE_TYPE_IS_PANEL:             FILE_TYPE_IS_PANEL,
 699                 FILE_TYPE_IS_SETTING:   FILE_TYPE_IS_SETTING
 700         }
 701 })();
 702
 703 pettanr.finder = ( function(){
 704         var FINDER_ARRAY = [],
 705                 ELM_ORIGIN_FINDER_LOCATION_ITEM = pettanr.util.pullHtmlAsTemplete( 'templete-finder-location-item'),
 706                 ELM_ORIGIN_FINDER_ICON = pettanr.util.pullHtmlAsTemplete( 'templete-finder-icon'),
 707                 ELM_ORIGIN_CONTAINER = pettanr.util.pullHtmlAsTemplete( 'templete-finder-container'),
 708                 ICON_HEIGHT = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON).height,
 709                 ICON_CLASSNAME = ELM_ORIGIN_FINDER_ICON.getElementsByTagName( 'div')[0].className,
 710                 FINDER_ICON_POOL = [],
 711                 BREAD_OBJECT_POOL = [];
 712
 713         var FinderIconClass = function(){
 714                 var elmContainer,
 715                         ELM_WRAPPER = ELM_ORIGIN_FINDER_ICON.cloneNode( true),
 716                         ELM_THUMBNAIL = ELM_WRAPPER.getElementsByTagName( 'div')[0],
 717                         ELM_FILENAME = ELM_WRAPPER.getElementsByTagName( 'div')[1],
 718                         file, w, index, style, instansce, callback;
 719
 720                 ELM_WRAPPER.onclick = onClick;
 721                 function onClick(){
 722                         callback( index);
 723                 }
 724
 725
 726                 function draw(){
 727                         var _thumb = file.getThumbnail();
 728                         if( _thumb !== null){
 729                                 ELM_THUMBNAIL.className = ICON_CLASSNAME + ' has-thumbnail';
 730                                 ELM_THUMBNAIL.style.backgroundImage = [ 'url(', _thumb, ')'].join( '');
 731                         } else {
 732                                 ELM_THUMBNAIL.className = ICON_CLASSNAME + ' file-type-' +file.TYPE();
 733                                 ELM_THUMBNAIL.style.backgroundImage = '';
 734                         }
 735                         ELM_FILENAME.innerHTML = file.getName();
 736                 }
 737                 function resize(){
 738                         ELM_WRAPPER.style.top = (index * ICON_HEIGHT) +'px';
 739                 }
 740                 function onCollect(){
 741                         elmContainer.removeChild( ELM_WRAPPER);
 742                         elmContainer = null;
 743                         FINDER_ICON_POOL.push( instansce);
 744                 }
 745
 746                 return {
 747                         init: function( _file, _elmContainer, _w, _index, _style, _callback){
 748                                 instansce = this;
 749                                 if( elmContainer !== _elmContainer){
 750                                         _elmContainer.appendChild( ELM_WRAPPER);
 751                                         elmContainer = _elmContainer;
 752                                 }
 753                                 if( file !== _file){
 754                                         file = _file;
 755                                         draw();
 756                                 }
 757                                 if( index !== _index){
 758                                         index = _index;
 759                                         resize();
 760                                 }
 761                                 callback = _callback;
 762                         },
 763                         elm: ELM_WRAPPER,
 764                         index: function( _index){
 765
 766                                 return index;
 767                         },
 768                         style: function( _style){
 769
 770                                 return style;
 771                         },
 772                         onResize: function( w){
 773
 774                         },
 775                         collect: function(){
 776                                 elmContainer.removeChild( ELM_WRAPPER);
 777                                 file = elmContainer = null;
 778                                 FINDER_ICON_POOL.push( this);
 779                         }
 780                 }
 781         }
 782         function updateIconPosition( _style, _w, _index, _elm){
 783
 784         }
 785         var BreadcrumbClass = function(){
 786                 var elmContainer,
 787                         ELM_WRAPPER = ELM_ORIGIN_FINDER_LOCATION_ITEM.cloneNode( true),
 788                         ELM_FILENAME = ELM_WRAPPER.getElementsByTagName( 'a')[0],
 789                         file, w, index, instansce,
 790                         callback;
 791                 ELM_WRAPPER.onclick = onClick;
 792                 function draw(){
 793                         ELM_FILENAME.className = 'file-icon-' +file.TYPE();
 794                         ELM_FILENAME.innerHTML = file.getName();
 795                 }
 796                 function resize( index){
 797                         ELM_WRAPPER.style.left = (index * 90) +'px';
 798                 }
 799                 function onClick(){
 800                         callback( index);
 801                 }
 802
 803                 return {
 804                         init: function( _file, _elmContainer, _index, _callback){
 805                                 instansce = this;
 806                                 if( elmContainer !== _elmContainer){
 807                                         _elmContainer.appendChild( ELM_WRAPPER);
 808                                         elmContainer = _elmContainer;
 809                                 }
 810                                 if( file !== _file){
 811                                         file = _file;
 812                                         draw();
 813                                 }
 814                                 if( index !== _index){
 815                                         index = _index;
 816                                         resize( index);
 817                                 }
 818                                 callback = _callback;
 819                         },
 820                         elm: ELM_WRAPPER,
 821                         index: function( _index){
 822
 823                                 return index;
 824                         },
 825                         onResize: function( w){
 826
 827                         },
 828                         collect: function(){
 829                                 elmContainer.removeChild( ELM_WRAPPER);
 830                                 file = elmContainer = null;
 831                                 BREAD_OBJECT_POOL.push( this);
 832                         }
 833                 }
 834         }
 835
 836         var FinderClass = function( ELM_CONTAINER, TREE_TYPE, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled){
 837                 var ICON_ARRAY = [],
 838                         BREAD_ARRAY = [],
 839                         elmContainer = ELM_ORIGIN_CONTAINER.cloneNode( true),
 840                         elmLocation = elmContainer.getElementsByTagName( 'ul')[0],
 841                         nodesDiv = elmContainer.getElementsByTagName( 'div'),
 842                         elmSidebarButton = nodesDiv[1],
 843                         elmStyleButton = nodesDiv[2],
 844                         elmActionButton = nodesDiv[3],
 845                         elmBody = nodesDiv[ nodesDiv.length -1],
 846                         tree = pettanr.file.createTree( TREE_TYPE),
 847                         headX,
 848                         headY,
 849                         headH = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON).height,
 850                         bodyY,
 851                         currentFile = null,
 852                         breadW = 90,
 853                         size = pettanr.util.getElementSize( ELM_ORIGIN_FINDER_ICON),
 854                         iconW = size.width,
 855                         iconH = size.height,
 856                         style = 0;
 857                         w = 800;
 858
 859                 tree.addTreeEventListener( 'onTreeUpdate', draw);
 860
 861                 function draw(){
 862                         var     l = tree.hierarchy() +1,
 863                                 m = BREAD_ARRAY.length,
 864                                 _file, _bread;
 865                         for(var i=0; i<l; ++i){
 866                                 _file = i !== l-1 ? tree.getParentFileAt( i) : tree.getCurrentFile();
 867                                 if( i < m){
 868                                         BREAD_ARRAY[ i].init( _file, elmLocation, i, onHeadClick);
 869                                 } else {
 870                                         BREAD_ARRAY.push( getBreadcrumb( _file, elmLocation, i, onHeadClick));
 871                                 }
 872                         }
 873                         while( l < BREAD_ARRAY.length){
 874                                 BREAD_ARRAY.pop().collect();
 875                         }
 876
 877                         l = _file.getChildFileLength();
 878                         m = ICON_ARRAY.length;
 879
 880                         for( i=0; i<l; ++i){
 881                                 if( i < m){
 882                                         ICON_ARRAY[ i].init( _file.getChildFileByIndex( i), elmBody, w, i, style, onBodyClick);
 883                                 } else {
 884                                         ICON_ARRAY.push( getFinderIcon( _file.getChildFileByIndex( i), elmBody, w, i, style, onBodyClick));
 885                                 }
 886                         }
 887                         while( l < ICON_ARRAY.length){
 888                                 ICON_ARRAY.pop().collect();
 889                         }
 890                 }
 891                 function onHeadClick( i){
 892                         var l = BREAD_ARRAY.length -1;
 893                         if( i < l){
 894                                 var _file = tree.getParentFileAt( i);
 895                                 if( _file !== null){
 896                                         tree.up( i);
 897                                         draw();
 898                                 }
 899                         }
 900                 }
 901                 function onBodyClick( i){
 902                         var l = ICON_ARRAY.length;
 903                         if( i < l){
 904                                 var _file = tree.getCurrentFile().getChildFileByIndex( i);
 905                                 if( _file !== null && _file.TYPE() === pettanr.file.FILE_TYPE_IS_FOLDER){
 906                                         tree.down( i);
 907                                         draw();
 908                                 }
 909                         }
 910                 }
 911
 912                 return {
 913                         init: function(){
 914                                 ELM_CONTAINER.appendChild( elmContainer);
 915                                 //$( elmLocation).click( onHeadClick);
 916                                 //$( elmContainer).click( onBodyClick);
 917                                 var position = pettanr.util.getAbsolutePosition( elmLocation);
 918                                 headX = position.x;
 919                                 headY = position.y;
 920                                 bodyY = pettanr.util.getAbsolutePosition( elmBody).y;
 921                                 delete this.init;
 922                         },
 923                         onOpen: function(){
 924                                 this.init !== undefined && this.init();
 925                                 draw();
 926                         },
 927                         onClose: function(){
 928
 929                         },
 930                         onWindowResize: function( _w, _h){
 931
 932                         }
 933                 }
 934         }
 935         function getFinderIcon( _file, _elmContainer, w, index, style, callback){
 936                 var _icon;
 937                 if( FINDER_ICON_POOL.length > 0){
 938                         _icon = FINDER_ICON_POOL.shift();
 939                 } else {
 940                         _icon = new FinderIconClass();
 941                 }
 942                 _icon.init( _file, _elmContainer, w, index, style, callback);
 943                 return _icon;
 944         }
 945
 946         function getBreadcrumb( _file, _elmContainer, index, callback){
 947                 var _bread;
 948                 if( BREAD_OBJECT_POOL.length > 0){
 949                         _bread = BREAD_OBJECT_POOL.shift();
 950                 } else {
 951                         _bread = new BreadcrumbClass();
 952                 }
 953                 _bread.init( _file, _elmContainer, index, callback);
 954                 return _bread;
 955         }
 956
 957         return {
 958                 init: function(){
 959
 960                 },
 961                 createFinder: function( _elmTarget, _treeType, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled){
 962                         var _finder = new FinderClass( _elmTarget, _treeType, detailSwitchEnabled, styleSwitchEnabled, actionSwitchEnabled);
 963                         FINDER_ARRAY.push( _finder);
 964                         return _finder;
 965                 }
 966         }
 967 })();
 968
 969 pettanr.gallery = ( function(){
 970         var finder,
 971                 elmContainer = document.getElementById( 'gallery'),
 972                 option;
 973
 974         return {
 975                 init: function( _option){
 976                         option = _option;
 977                         delete pettanr.gallery.init;
 978                 },
 979                 firstOpen: function(){
 980                         finder = pettanr.finder.createFinder( elmContainer, pettanr.file.TREE_TYPE_IS_IMAGE);
 981                         delete pettanr.gallery.firstOpen;
 982                 },
 983                 onOpen: function(){
 984                         pettanr.gallery.firstOpen !== undefined && pettanr.gallery.firstOpen();
 985                         finder.onOpen();
 986
 987                 },
 988                 onClose: function(){
 989                         finder.onClose();
 990                 },
 991                 onWindowResize: function( _w, _h){
 992                         finder.onWindowResize( _w, _h);
 993                 }
 994         }
 995 })();
 996
 997 pettanr.cabinet = ( function(){
 998         var finder,
 999                 elmContainer = document.getElementById( 'cabinet'),
1000                 option;
1001
1002         return {
1003                 init: function( _option){
1004                         option = _option;
1005                         delete pettanr.cabinet.init;
1006                 },
1007                 firstOpen: function(){
1008                         finder = pettanr.finder.createFinder( elmContainer, pettanr.file.TREE_TYPE_IS_COMIC);
1009                         delete pettanr.cabinet.firstOpen;
1010                 },
1011                 onOpen: function(){
1012                         pettanr.cabinet.firstOpen !== undefined && pettanr.cabinet.firstOpen();
1013                         finder.onOpen();
1014
1015                 },
1016                 onClose: function(){
1017                         finder.onClose();
1018                 },
1019                 onWindowResize: function( _w, _h){
1020                         finder.onWindowResize( _w, _h);
1021                 }
1022         }
1023 })();
1024
1025 // i18n
1026 // login
1027 // lib
1028
1029 pettanr.fn( pettanr.view);
1030 pettanr.fn( pettanr.overlay);
1031 pettanr.fn( pettanr.key);
1032 pettanr.fn( pettanr.balloon);
1033 pettanr.fn( pettanr.editor);
1034 pettanr.fn( pettanr.file);
1035 pettanr.fn( pettanr.finder);
1036 pettanr.fn( pettanr.gallery);
1037 pettanr.fn( pettanr.cabinet);
1038
1039 $(window).ready( pettanr.init);