DocumentTemplateImpl.java :  » Ajax » ItsNat » org » itsnat » impl » core » Java Open Source

/*
  ItsNat Java Web Application Framework
  Copyright (C) 2007 Innowhere Software Services S.L., Spanish Company
  Author: Jose Maria Arranz Santamaria

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version. See the GNU Affero General Public 
  License for more details. See the copy of the GNU Affero General Public License
  included in this program. If not, see <http://www.gnu.org/licenses/>.
*/

package org.itsnat.impl.core;

import java.text.DateFormat;
import java.text.NumberFormat;
import java.util.HashMap;
import java.util.Iterator;
import org.itsnat.core.DocumentTemplate;
import org.itsnat.core.event.ItsNatServletRequestListener;
import org.itsnat.core.event.RemoteControlEventListener;
import java.util.LinkedList;
import java.util.Map;
import org.itsnat.comp.CreateItsNatComponentListener;

/**
 *
 * @author jmarranz
 */
public abstract class DocumentTemplateImpl extends MarkupTemplateImpl implements DocumentTemplate
{
    protected LinkedList requestListeners;
    protected LinkedList remControlListeners;
    protected LinkedList createCompListeners;     
    protected int syncMode;
    protected long ajaxTimeout;    
    protected int useGZip;
    protected boolean autoBuildComponents;   
    protected boolean fastLoadMode; // No tiene efectos en documentos XML ... para el futuro
    protected boolean loadScriptInline; // No tiene efectos en documentos XML ... para el futuro
    protected boolean nodeCacheEnabled; // No tiene efectos en documentos XML ... para el futuro
    protected String jsFilesBasePath;
    protected boolean addJSFiles;
    protected DateFormat dateFormat;
    protected NumberFormat numberFormat; 
    protected long evtDispMaxWait;
    protected boolean referrerEnabled;
    protected boolean referrerPushEnabled;    
    protected boolean ajaxEnabled;
    protected boolean scriptEnabled; 
    protected boolean autoCleanEventListeners;
    protected Map artifacts;
    protected boolean usePatternMarkupToRender;     

    
    /**
     * Creates a new instance of DocumentTemplate
     */
    public DocumentTemplateImpl(String name,String mime,String path,ItsNatServletImpl servlet)
    {
        super(name,mime,path,servlet);
        
        ItsNatServletConfigImpl servletConfig = servlet.getItsNatServletConfigImpl();
        this.syncMode = servletConfig.getDefaultSyncMode();
        this.ajaxTimeout = servletConfig.getAJAXTimeout();
        this.useGZip = servletConfig.getUseGZip();
        this.fastLoadMode = servletConfig.isFastLoadMode();
        this.loadScriptInline = servletConfig.isLoadScriptInline(); 
        this.nodeCacheEnabled = servletConfig.isNodeCacheEnabled();
        
        this.jsFilesBasePath = servletConfig.getFrameworkScriptFilesBasePath();
        this.addJSFiles = servletConfig.isAddFrameworkScriptFiles();
        
        this.dateFormat = servletConfig.getDefaultDateFormat();
        this.numberFormat = servletConfig.getDefaultNumberFormat();        
        
        this.evtDispMaxWait = servletConfig.getEventDispatcherMaxWait();
                
        this.autoBuildComponents = servletConfig.isAutoBuildComponents();
        
        this.referrerEnabled = servletConfig.isReferrerEnabled();
        
        this.referrerPushEnabled = servletConfig.isReferrerPushEnabled();
        
        this.ajaxEnabled = servletConfig.isAJAXEnabled();
        
        this.scriptEnabled = servletConfig.isScriptingEnabled();
        
        this.autoCleanEventListeners = servletConfig.isAutoCleanEventListeners();
                
        this.usePatternMarkupToRender = servletConfig.isUsePatternMarkupToRender();     
    }
    
    public int getDefaultSyncMode()
    {
        return syncMode;
    }
    
    public void setDefaultSyncMode(int syncMode)
    {
        checkIsAlreadyUsed();         
        ItsNatServletConfigImpl.checkSyncMode(syncMode);        
        this.syncMode = syncMode;
    }    
    
    public long getAJAXTimeout()
    {
        return ajaxTimeout;
    }
    
    public void setAJAXTimeout(long timeout)
    {
        checkIsAlreadyUsed();        
        this.ajaxTimeout = timeout;
    }
    
    public int getUseGZip()
    {
        return useGZip;
    }
    
    public void setUseGZip(int value)   
    {
        checkIsAlreadyUsed();        
        this.useGZip = value;
    }     
    
    public boolean isFastLoadMode()
    {
        return fastLoadMode;
    }
    
    public void setFastLoadMode(boolean fastLoadMode)
    {
        checkIsAlreadyUsed();         
        this.fastLoadMode = fastLoadMode;
    }    
        
    public boolean isLoadScriptInline()
    {
        return loadScriptInline;
    }
    
    public void setLoadScriptInline(boolean value)
    {
        checkIsAlreadyUsed();         
        this.loadScriptInline = value;
    }    
    
    public boolean isNodeCacheEnabled()
    {
        return nodeCacheEnabled;
    }
    
    public void setNodeCacheEnabled(boolean nodeCacheEnabled)
    {
        checkIsAlreadyUsed();         
        this.nodeCacheEnabled = nodeCacheEnabled;      
    }    
    
    public boolean isAutoBuildComponents()
    {
        return autoBuildComponents;
    }

    public void setAutoBuildComponents(boolean autoBuildComponents)
    {
        checkIsAlreadyUsed();        
        this.autoBuildComponents = autoBuildComponents;     
    }    
    
    public String getFrameworkScriptFilesBasePath()
    {
        return jsFilesBasePath;
    }
    
    public void setFrameworkScriptFilesBasePath(String path)
    {
        checkIsAlreadyUsed();         
        this.jsFilesBasePath = path;      
    }

    public boolean isAddFrameworkScriptFiles()
    {
        return addJSFiles;
    }    

    public void setAddFrameworkScriptFiles(boolean value)
    {
        checkIsAlreadyUsed(); 
        this.addJSFiles = value;
    }     
    
    public DateFormat getDefaultDateFormat()
    {
        return dateFormat;
    }

    public void setDefaultDateFormat(DateFormat dateFormat)
    {
        checkIsAlreadyUsed();        
        this.dateFormat = dateFormat;
    }   
    
    public NumberFormat getDefaultNumberFormat()
    {
        return numberFormat;
    }

    public void setDefaultNumberFormat(NumberFormat numberFormat)
    {
        checkIsAlreadyUsed();        
        this.numberFormat = numberFormat;
    }        
    
    public long getEventDispatcherMaxWait()
    {
        return evtDispMaxWait;
    }
    
    public void setEventDispatcherMaxWait(long wait)
    {
        checkIsAlreadyUsed();        
        this.evtDispMaxWait = wait;
    }          

    public boolean isReferrerEnabled()
    {
        return referrerEnabled;
    }

    public void setReferrerEnabled(boolean enabled)
    {
        checkIsAlreadyUsed();         
        this.referrerEnabled = enabled;
    }        
    
    
    public boolean isReferrerPushEnabled()    
    {
        return referrerPushEnabled;
    }    
    
    public void setReferrerPushEnabled(boolean referrerPushEnabled)
    {
        checkIsAlreadyUsed();        
        this.referrerPushEnabled = referrerPushEnabled;     
    }        
    
    public boolean isAJAXEnabled()
    {
        return ajaxEnabled;
    }

    public void setAJAXEnabled(boolean enabled)
    {
        checkIsAlreadyUsed();         
        this.ajaxEnabled = enabled;
    }      
    
    public boolean isScriptingEnabled()
    {
        return scriptEnabled;
    }

    public void setScriptingEnabled(boolean enabled)
    {
        checkIsAlreadyUsed();                 
        this.scriptEnabled = enabled;
        
        if (!enabled)
        {
            setAJAXEnabled(false);
            setFastLoadMode(true); // Pues el modo "slow" necesariamente necesita enviar JavaScript por los cambios en el DOM en tiempo de carga
        }        
    }     
    
    public boolean isAutoCleanEventListeners()
    {
        return autoCleanEventListeners;
    }           

    public void setAutoCleanEventListeners(boolean enable)
    {
        checkIsAlreadyUsed();
        
        this.autoCleanEventListeners = enable;
    }    
    
    public boolean isUsePatternMarkupToRender()
    {
        return usePatternMarkupToRender;
    }

    public void setUsePatternMarkupToRender(boolean usePatternMarkupToRender)
    {
        checkIsAlreadyUsed();        
        this.usePatternMarkupToRender = usePatternMarkupToRender;
    }     
    
    public DocumentTemplateVersionImpl getDocumentTemplateVersion()
    {
        return (DocumentTemplateVersionImpl)getMarkupTemplateVersion();
    }
    
    
    public LinkedList getItsNatServletRequestListenerList()
    {    
        if (requestListeners == null)
            this.requestListeners = new LinkedList();
        return requestListeners;      
    } 
    
    public Iterator getItsNatServletRequestListenerIterator()
    {    
        // No sincronizamos porque slo admitimos slo lectura
        if (requestListeners == null) return null;
        if (requestListeners.isEmpty()) return null;
        return requestListeners.iterator();      
    }

    
    public void addItsNatServletRequestListener(ItsNatServletRequestListener listener)
    {
        checkIsAlreadyUsed(); // As evitamos sincronizar la lista pues si es slo lectura admite mltiples hilos 
        
        LinkedList requestListeners = getItsNatServletRequestListenerList();
        requestListeners.add(listener);        
    }    

    public void removeItsNatServletRequestListener(ItsNatServletRequestListener listener)
    {
        checkIsAlreadyUsed(); // As evitamos sincronizar la lista pues si es slo lectura admite mltiples hilos                 
        
        LinkedList requestListeners = getItsNatServletRequestListenerList();        
        requestListeners.remove(listener);        
    }        

    
    public LinkedList getRemoteControlEventListenerList()
    {    
        if (remControlListeners == null)
            this.remControlListeners = new LinkedList();
        return remControlListeners;      
    }    
    
    public Iterator getRemoteControlEventListenerIterator()
    {    
        // No sincronizamos porque slo admitimos slo lectura
        if (remControlListeners == null)
            return null;
        if (remControlListeners.isEmpty()) return null;
        return remControlListeners.iterator();      
    }    
    
    public void addRemoteControlEventListener(RemoteControlEventListener listener)
    {
        checkIsAlreadyUsed(); // As evitamos sincronizar la lista pues si es slo lectura admite mltiples hilos 
        
        LinkedList remControlListeners = getRemoteControlEventListenerList();
        remControlListeners.add(listener);        
    }    

    public void removeRemoteControlEventListener(RemoteControlEventListener listener)
    {
        checkIsAlreadyUsed(); // As evitamos sincronizar la lista pues si es slo lectura admite mltiples hilos                 
        
        LinkedList remControlListeners = getRemoteControlEventListenerList();        
        remControlListeners.remove(listener);        
    }        

    
    public LinkedList getCreateItsNatComponentList()    
    {
        if (createCompListeners == null)
            this.createCompListeners = new LinkedList(); // Slo se crea si se necesita
        return createCompListeners;
    }
    
    public Iterator getCreateItsNatComponentListenerIterator()    
    {
        if (createCompListeners == null)
            return null;
        if (createCompListeners.isEmpty()) return null;
        return createCompListeners.iterator();
    }
    
    public void addCreateItsNatComponentListener(CreateItsNatComponentListener listener)
    {
        checkIsAlreadyUsed(); // As evitamos sincronizar la lista pues si es slo lectura admite mltiples hilos                 
        
        LinkedList list = getCreateItsNatComponentList();
        list.add(listener);
    }
    
    public void removeCreateItsNatComponentListener(CreateItsNatComponentListener listener)
    {
        checkIsAlreadyUsed(); // As evitamos sincronizar la lista pues si es slo lectura admite mltiples hilos                 
        
        LinkedList list = getCreateItsNatComponentList();
        list.remove(listener);        
    }    


    
    public boolean hasArtifacts()
    {
        if (artifacts == null) return false;
        return !artifacts.isEmpty();
    }
    
    public Map getArtifactMap()
    {
        if (artifacts == null)
            this.artifacts = new HashMap();
        return artifacts;
    }
    
    public Object getArtifact(String name)
    {
        if (!hasArtifacts()) return null;
        
        Map artifacts = getArtifactMap();
        return artifacts.get(name);        
    }
    
    public void registerArtifact(String name,Object value)
    {
        checkIsAlreadyUsed(); // As evitamos sincronizar (slo lectura)
        
        Map artifacts = getArtifactMap();
        artifacts.put(name,value);        
    }
    
    public Object removeArtifact(String name)
    {
        checkIsAlreadyUsed(); // As evitamos sincronizar (slo lectura)
        
        Map artifacts = getArtifactMap();
        return artifacts.remove(name);        
    }
       
    public Object getArtifact(String name,boolean cascade)
    {    
        Object artif = getArtifact(name);
        if (cascade && (artif == null))
            artif = getItsNatServletImpl().getItsNatServletConfigImpl().getArtifact(name);
        return artif;
    }
}