### XSLT Class ###
### setzt 4 suite vorraus ###
from Acquisition import Implicit
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Globals import DTMLFile
from ECHO_Nav import ECHO_pageTemplate
from threading import Thread,Timer
import threading
from ECHO_helpers import *
import sys
import urllib
import urlparse


from Globals import package_home


import os.path

import urllib

try:
    from Ft.Xml.Xslt.Processor import Processor
    from Ft.Xml import InputSource
    
except:
    print "4suite has to be installed"


class getXML(Implicit):
    """get XML thread"""

    def set(self,qs,xsl,result):
        """set"""
   
        self._v_qs=qs
        self.xsl=xsl
        self.result=None        

#    def acquireLock(self):
#    
#         lock=getattr(self, "_v_lock", None)
#         if not lock:
#             self._v_lock=threading.Lock()
#             lock=self._v_lock
#         lock.acquire()
#
#    def releaseLock(self):
#         # acquire() should have been called
#         # about one second before. This means the volatile lock
#         # should still be there
#    
#         self._v_lock.release()
#        
  
    def __call__(self):
        """wait"""
        return True
    
    def run(self):
        """call it"""
        xml=""
        
        try:
      
            urlH=urllib.urlopen(self._v_qs)
            xml=urlH.read()
            urlH.close()
            xsltproc=Processor()
            document = InputSource.DefaultFactory.fromString(xml)
            
            stylesheet = InputSource.DefaultFactory.fromUri(self.xsl)
            
            xsltproc.appendStylesheet(stylesheet)
            
        
            #print self.xsl
            #print xsltproc.run(document)
            tmp=xsltproc.run(document)
            
            self.result=tmp[0:]
            
        
       	except:
               
               self.result="<html>error: %s %s<br>"%sys.exc_info()[0:2]
               self.result+=xml
               self.result+="</html>"
        
        
    def getResult(self):

        return self.result


class ECHO_xslt(ECHO_pageTemplate):
    """ECHO_xslt classe"""

    meta_type="ECHO_xslt"
    
    results={}
    manage_options=ECHO_pageTemplate.manage_options+(
     {'label':'Change xml-ressource','action':'change_ECHO_xsltForm'},)
     
    def refreshTxt(self):
        """txt fuer refresh"""
        return """ 2;url=%s?repeat=%s """%(self.absolute_url(),self.threadName)

    def xslt(self):
        """xslt"""

        return self.document_src()

    def change_ECHO_xsltForm(self):
        """change form"""
        pt=zptFile(self, 'zpt/ChangeECHO_xsltForm.zpt')
        return pt()

    def addChanges(self,cgiUrl,RESPONSE=None):
        """change the xslt, ueberschriebt addChanges in ECHO_PageTemplate"""
        if urlparse.urlparse(cgiUrl)[0]=="":#relative url in absolute
            self.cgiUrl=urlparse.urljoin(self.absolute_url(), cgiUrl)
        else:
            self.cgiUrl=cgiUrl
            
        if RESPONSE:
            RESPONSE.redirect("manage_main")
        
    def index_html(self,repeat=None):
        """standard ausgabe"""

        threadName=repeat
        
        if not threadName or threadName=="":
            
            #abwaertskompatibilitŠt mit altem nivht konfigurierbaren prototypen
            
            if getattr(self,'cgiUrl','')=='':
                self.cgiUrl="http://medea.mpiwg-berlin.mpg.de/cgi-bin/search/q1"
                
            qs="%s?%s"%(self.cgiUrl,self.REQUEST['QUERY_STRING'])
            xsl=self.absolute_url()+"/xslt"
            self._v_xmltrans=getXML().__of__(self)
            #self._xmltrans.start()
            thread=Thread(target=self._v_xmltrans)
            thread.start()
            self._v_xmltrans.set(qs,xsl,None)
            self._v_xmltrans.run()
            
            
            self.threadName=thread.getName()[0:]
            wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
            if wait_template:
                return wait_template[0][1]()
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self)
            return pt()
            #_v_xmltrans.run()
        
        else:
            
            if (self._v_xmltrans.getResult()==None):

            	wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
            	if wait_template:
                	return wait_template[0][1]()
                
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self)
                return pt()
            else:
                return self._v_xmltrans.getResult()

    
def manage_addECHO_xsltForm(self):
    """Form for adding"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_xslt.zpt')).__of__(self)
    return pt()

from urllib import quote


def manage_addECHO_xslt(self, id, label, weight= 0,contentType=0,title=None, text=None, cgiUrl=None,
                           REQUEST=None, submit=None):
    "Add a Page Template with optional file content."

    
    id = str(id)
    if REQUEST is None:
        self._setObject(id, ECHO_xslt(id, text))
        ob = getattr(self, id)
        setattr(ob,'weight',weight)
        setattr(ob,'label',label)
        setattr(ob,'contentType',contentType)
        if title:
            ob.pt_setTitle(title)
        return ob
        setattr(ob,'cgiUrl',cgiUrl)
    else:
        file = REQUEST.form.get('file')
        headers = getattr(file, 'headers', None)
        if headers is None or not file.filename:
            zpt = ECHO_xslt(id)
        else:
            zpt = ECHO_xslt(id, file, headers.get('contentType'))

        self._setObject(id, zpt)
        ob = getattr(self, id)
        setattr(ob,'weight',weight)
        setattr(ob,'label',label)
        setattr(ob,'cgiUrl',cgiUrl)
        if title:
            ob.pt_setTitle(title)
        
        try:
            u = self.DestinationURL()
        except AttributeError:
            u = REQUEST['URL1']

        if submit == " Add and Edit ":
            u = "%s/%s" % (u, quote(id))
        REQUEST.RESPONSE.redirect(u+'/manage_main')
    return ''