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