/*
 * m8 application server 1.0.1
 * Portal 1.0
 * 
 * 
 */


// quicktips
  Ext.QuickTips.init();
  Ext.apply(Ext.QuickTips.getQuickTip(), {
    showDelay: 50,
    dismissDelay: 0,
    trackMouse: false
  });
  
// some defaults
  Ext.AppSrvUrl = 'appsrv';
  Ext.BLANK_IMAGE_URL = (function() {
    if (Ext.isIE8 || Ext.isGecko || Ext.isOpera) {
      return "data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==";
    } else {
      return "media/appsrv/images/blank.png";
    }
  })();

// history
/*
  Ext.History.init();
  Ext.History.on('change', function(token) {
    if(!token) {
      App.loadUrl('portal');
    }
    var parts  = token.split(tokenDelimiter);
    var url    = parts[0];
    var params = parts[1];
    if(params) {
      params = Ext.urlDecode(params);
    }
    //console.log('Token:'+token); console.log('Params:'+params); console.log('Loc:'+url); console.log('OLD: '+App.url);
    if(url == App.url) {
      return false;
    }
    if(token.match(/render/g)) {
      App.loadUrl(url);
    } else {  
      App.layout(url, params, false);
    }
  }, Ext.History);
*/
    
// Needed if you want to handle history for multiple components in the same page.
// Should be something that won't be in component ids.
  var tokenDelimiter = ':';

// set updater
  Ext.Updater.defaults.loadScripts        = true;
  Ext.Updater.defaults.indicatorText      = "<div class=\"loading-indicator\">Lade...</div>";
  Ext.Updater.defaults.showLoadIndicator  = false;

// state provider
  var cp = new Ext.state.CookieProvider({
     path: "/", expires: new Date(new Date().getTime()+(1000*60*60*24*30)) //30 days
  });
  Ext.state.Manager.setProvider(cp);

// desktop object
  Ext.Desktop = function(){
    
    var desktop   = Ext.get('x-desktop');
    var taskbar   = Ext.get('x-taskbar');
    var windows   = new Ext.WindowGroup();
    windows.zseed = 100;
    var activeWindow;

    function saveState(win){
      var size = win.getSize();
      Ext.state.Manager.set(win.id+'-x', win.x);
      Ext.state.Manager.set(win.id+'-y', win.y);
      Ext.state.Manager.set(win.id+'-w', size.width);
      Ext.state.Manager.set(win.id+'-h', size.height);
    }

    function restoreState(win){
      win.x       = (Ext.state.Manager.get(win.id+'-x')) ? Ext.state.Manager.get(win.id+'-x') : win.x;
      win.y       = (Ext.state.Manager.get(win.id+'-y')) ? Ext.state.Manager.get(win.id+'-y') : win.y;
      win.width   = (Ext.state.Manager.get(win.id+'-w')) ? Ext.state.Manager.get(win.id+'-w') : win.width;
      win.height  = (Ext.state.Manager.get(win.id+'-h')) ? Ext.state.Manager.get(win.id+'-h') : win.height;
      //console.log(win.y);
    }

    function minimizeWin(win){
      win.minimized = true;
      win.hide();
    }

    function markActive(win){
      if(activeWindow && activeWindow != win){
        markInactive(activeWindow);
      }
      activeWindow = win;
      activeWindow.addClass('x-window-focus');
      win.minimized = false;
    }

    function markInactive(win){
      if(win == activeWindow){
        activeWindow.removeClass('x-window-focus');
        activeWindow = null;
      }
    }

    function removeWin(win){
      win.destroy();
      layout();
    }

    function layout(){
      desktop.setHeight(Ext.lib.Dom.getDocumentHeight()-(taskbar ? taskbar.getHeight() : 0) - 1);
    }
    Ext.EventManager.onWindowResize(layout);

    this.layout = layout;

    this.createWindow = function(config, cls){
       var win = new (cls||Ext.Window)(
           Ext.applyIf(config||{}, {
               manager: windows,
               minimizable: false,
               maximizable: false
           })
       );

       win.render(desktop);
       //win.taskItem =  new Ext.Desktop.TaskBarItem(win);

       win.on('activate', markActive);
       win.on('beforeshow', markActive);
       win.on('deactivate', markInactive);
       win.on('minimize', minimizeWin);
       win.on('close', removeWin);
       layout();
       return win;
    };

    this.getManager = function(){
        return windows;
    };

    this.getWindow = function(id){
      return windows.get(id);
    }

    this.getWinWidth = function(){
      var width = Ext.lib.Dom.getViewWidth();
      return width < 200 ? 200 : width;
    }

    this.getWinHeight = function(){
      var height = (Ext.lib.Dom.getViewHeight() - 302);
      return height < 100 ? 100 : height;
    }

    this.getWinX = function(width){
      return (Ext.lib.Dom.getViewWidth() - width) / 2
    }

    this.getWinY = function(height){
      //console.log((Ext.lib.Dom.getViewHeight() - height) / 2);
      //return (Ext.lib.Dom.getViewHeight() - height) / 2;
      return 200;
    }
    
    this.getHeight = function(){
      return desktop.getHeight();
    };
    
    this.removeWin = removeWin;

    layout();
  };


// overwrite panel (memory leak!)
  // later...

// portlet
  Ext.ux.Portlet = Ext.extend(Ext.Panel, {
    collapsible:false,
    draggable: false,
    floating: false,
    frame: true,
    autoScroll: true,
    cls:'x-portlet',
    style: ''
  });
  Ext.reg('portlet', Ext.ux.Portlet);


// portal column
  Ext.ux.PortalColumn = Ext.extend(Ext.Panel, {
    layout: 'anchor',
    cls: 'x-portal-column'
  });
  Ext.reg('portalcolumn', Ext.ux.PortalColumn);


// portal
  Ext.ux.Portal = Ext.extend(Ext.Panel, {
    layout: 'border',
    autoScroll:true,
    cls:'x-portal',
    defaultType: 'portalcolumn',

    initComponent : function(){
        Ext.ux.Portal.superclass.initComponent.call(this);
        this.addEvents({
            validatedrop:true,
            beforedragover:true,
            dragover:true,
            beforedrop:true,
            drop:true
        });
    },

    initEvents : function(){
        Ext.ux.Portal.superclass.initEvents.call(this);
        //this.dd = new Ext.ux.Portal.DropZone(this, this.dropConfig);
    }
  });
  Ext.reg('portal', Ext.ux.Portal);
  

// app controller
  Ext.app.App = function(cfg){
      Ext.apply(this, cfg);
      this.addEvents({
          'ready' : true,
          'beforeunload' : true,
          'sessionexpire': true
      });
      Ext.onReady(this.initApp, this);
  };

  Ext.extend(Ext.app.App, Ext.util.Observable, {
    isReady: false,

    initApp : function(){
      this.desktop  = new Ext.Desktop();
      this.init();
      Ext.EventManager.on(window, 'beforeunload', this.onUnload, this);
      this.fireEvent('ready', this);
      this.isReady = true;
    },

    getModules : Ext.emptyFn,
    init : Ext.emptyFn,

    initModules : function(ms){
    },

    onReady : function(fn, scope){
      if(!this.isReady){
        this.on('ready', fn, scope);
      }else{
        fn.call(scope, this);
      }
    },

    getDesktop : function(){
      return this.desktop;
    },

    onUnload : function(e){
      if(this.fireEvent('beforeunload', this) === false){
        e.stopEvent();
      }
    }
});


// module controller
  Ext.app.Module = function(config){
     Ext.apply(this, config);
     Ext.app.Module.superclass.constructor.call(this);
     this.init();
  }

  Ext.extend(Ext.app.Module, Ext.util.Observable, {
		init : function(){
		  //
		}
  });


// create app controller
  var App = App || {};

  App = new Ext.app.App({
    
    init :function(){
      this.Com = {};
      //this.RegisteredModules = [];
    },

    getModules : function(){
    },
    
    resetModules : function(){
      
	  },
    
    getArea: function(id){
      return 'x-area-'+id;
    },
    
    getArticle: function(id){
      return Ext.getCmp('x-article-'+id);
    },

    loadUrl: function(url) {
      if(url.indexOf('http') != -1) {
        document.location.href = url;
      } else {
        baseURL = document.baseURI || document.getElementsByTagName("base")[0].href;
        document.location.href = baseURL+url;
      }
    },
    
    log: function(t) {
      Ext.get('x-logger').update(t);
    },
    
    register: function(obj) {
    },
    
    plugin: function(remoteUrl){
      return new Ext.ux.Plugin.RemoteComponent({
        url : remoteUrl
      });
    },
    
    // load js file and exec
    load: function(url, params, callback, scope) {
      Ext.getBody().mask(Ext.waitWindow);
      Ext.Ajax.request({
        url: url,
        success: function(response) {
          eval(response.responseText);
          Ext.getBody().unmask();
        },
				failure: function(response) {
          //Ext.Msg.alert(response.result.title, response.result.message);
					//console.log(response);
          Ext.getBody().unmask();
        },
        callback: callback,
        scope: scope,
        params: params
      });
    },
		
		// load js file and exec
    process: function(url, params, callback, scope) {
      Ext.Ajax.request({
        url: url,
        callback: callback,
				text: "Loading...",
        scope: scope,
        params: params
      });
    },
    
    // mask
    mask: function(title) {
      Ext.getBody().mask('Loading...') ;
    },    
    
    // track history
    track: function(url, params) {
      if(params) {
        if(params.extended) {
          url += ':'+Ext.urlEncode({extened: 1});
        } else {
          url += ':'+Ext.urlEncode(params);
        }
      }
      //console.log('Track: '+url); console.log(params);
      Ext.History.add(url);
    }, 
    
    // load page layout
    layout: function(url, params, track) {
      if(!url) url = orgRequestUri;
      this.url     = url;
      this.request = url.split('/');
      this.mask();
      // update
      var p = Ext.get('x-portal');
      var u = p.getUpdater();
      u.setRenderer({
        render: function(el, res, updater, callback) {
          for(var i=0; i<p.items.items.length; i++) {
            p.items.items[i].destroy();
          }
          p.add(Ext.ComponentMgr.create(Ext.decode(res.responseText), 'panel')).show();
          p.doLayout();
          if(callback) callback();
        }
      });
      u.update({url: url, params: params});
    },
    
    // make a full search
    search: function(queryStr, id, limit) {
      Ext.getBody().mask('Suche nach &quot;'+queryStr+'&quot; ...');
      var id      = (id) ? id : '18';
      var url     = 'page/layout/id/'+id;
      var params  = {queryStr: queryStr, limit: limit};
      this.track(url, {queryStr: queryStr, caller: 'search'});
      Ext.getCmp('x-portal').load({
        url: url,
        params: params,
        discardUrl: false,
        nocache: false,
        timeout: 30,
        scripts: true
      });
    },
    
    // load js to component
    update: function(c, url, params) {
      Ext.getCmp(c).load({
        url: url,
        params: params, // or a URL encoded string
        scope: this, // optional scope for the callback
        discardUrl: false,
        nocache: false,
        text: "Loading...",
        timeout: 30,
        scripts: true
      });
    },

    // open window
    open: function(url, params) {
      if(!Ext.get('TempUpdater')) {
        Ext.getBody().createChild({id:'TempUpdater', style: 'display:none'});
      }
      // get dependencies
      //this.getDependencies(url);
      // request
      Ext.get('TempUpdater').load({
          url: url,
          scripts:true,
          showLoadIndicator: true,
          params: params,
          text: "Loading Foo..."
      });
    }
    
  });