"""version 1 des Imageservers, wird ersetzt durch version2"""

genericServerPath="http://www.mpiwg-berlin.mpg.de/zogilib_images" #can be changed with main config


from Ft.Xml.Domlette import NonvalidatingReader
from OFS.Folder import Folder
from OFS.OrderedFolder import OrderedFolder
from OFS.SimpleItem import SimpleItem
from Globals import Persistent,package_home
from Acquisition import Implicit
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from xmlrpclib import ServerProxy
import re
import os
import os.path
import urllib
import xml.dom.minidom
import operator
import tempfile
import shutil
from types import *
import time
from threading import Thread
import Queue
import cgi
import sys

import shutil

import logging

#ersetzt logging
def logger(txt,method,txt2):
    """logging"""
    logging.info(txt+ txt2)

def logTime(msg=""):
    """log the time"""
    logging.info("%s %s"%(msg,time.clock()))
    

from AccessControl import ClassSecurityInfo, getSecurityManager

try:
    from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
except:
    print "ZSQL Extend Folder nicht importiert"
    print "Metadatendfolder funktioniert nicht!!!"
    class ZSQLExtendFolder:
        """leer"""
        manage_options=()



try:
    from Products.ECHO_content.ECHO_collection import ECHO_basis
except:
    print "ECHO Elements not imported"
    class ECHO_basis:
        """leer"""

        manage_options=()

tdir="tmp"
#tdir = "/mpiwg/temp/tmp/archivesImageServer/"
#tdir="/tmp/archivesImageServer/"

imageExtensions=['.jpg','.jpeg','.tif','.tiff','.png','.gif']

def splitPath(str):
        str2=str.replace("\\","/")
        return os.path.split(str2)[1]

def getText(nodelist):
    
    rc = ""
    for node in nodelist:
    
        if node.nodeType == node.TEXT_NODE:
           rc = rc + node.data
    return rc

def getTextFromNode(nodename):
    nodelist=nodename.childNodes
    rc = ""
    for node in nodelist:
        if node.nodeType == node.TEXT_NODE:
           rc = rc + node.data
    return rc

class generateSet:
    """generateSetThread"""

        
    def __init__(self,filenames,filenamesIds,ImageViewerPath,ImageStoragePath,destBasis,ids,url,local=None,version="working"):
        """init generateSet"""
        self.filenames=filenames
        self.filenamesIds=filenamesIds
        self.ImageViewerPath=ImageViewerPath
        self.ImageStoragePath=ImageStoragePath
        self.destBasis=destBasis
        self.ids=ids
        self.local=local
        self.url=url
        self.version=version
        self.done=None
        self.response=""
        

    def __call__(self):
        """call generate Set"""

        storeTempDir=tempfile.tempdir
        tempfile.tempdir=tdir

        tmpPath=tempfile.mktemp()
        tmpZip=tempfile.mktemp()+".gtz"
        tmpFn=os.path.split(tmpZip)[1]

        if not os.path.exists(tempfile.tempdir):
            os.mkdir(tempfile.tempdir) 

        if not os.path.exists(tmpPath):
                    os.mkdir(tmpPath) 
            
        self.response=""

        
        self.response="<h3>1. step: getting the images</h3>"

        for id in self.filenames:

                    if self.filenamesIds.has_key(id[0]) and self.filenamesIds[id[0]][0]:
                            filename=self.filenamesIds[id[0]][0]+"_"+id[0]
                    else:
                            filename=id[0]

                    self.response+=str("<p>Get File: %s<br>\n"%filename)

                    toggle=False
                    
                    if self.local:
                            
                            if self.version=="working":
                                
                                    sourcePath=self.destBasis+"/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"
                                    if not os.path.exists(sourcePath):
                                            self.response+=str("<p>%s doesn't exist I'll try the non scaled image</p>"%sourcePath)
                                            toggle=True
                            if (self.version!="working") or toggle:
                                    toggle=False
                                    sourcePath=self.ImageStoragePath+"/"+id[0]
                                    if not os.path.exists(sourcePath):
                                        sourcePath=self.ImageStoragePath+"/"+os.path.splitext(id[0])[0]+".jpg"
                                                      
                            targetPath=tmpPath+"/"+filename
                            try:
                                shutil.copyfile(sourcePath,targetPath)
                            except:
                                self.response+=(str("<p>Error in File: %s (possible missing)<br>\n"%sourcePath))
                    else:
                            if self.version=="working":
                                    requestString=self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&dh=2000&dw=2000"
                                    path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString

                            else:
                                    requestString=self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
                                    path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
                                

                            image=urllib.urlopen(path).read()
                    
                    
                            fh=file(tmpPath+"/"+filename,"w")

                    
                            fh.write(image)
                            fh.close()

                    #folgeseiten

                    if int(self.filenamesIds[id[0]][1])>1: 
                            #ids=self.show_thumbs()
                            
                            try:
                                nr=self.ids.index(id[0])
                            except:
                                self.response+=str("<p>Error in File: %s (possible missing)<br>\n"%id[0])
                

                                nr=0

                            numberOfPages=self.filenamesIds[id[0]][1]
                            for k in range(int(numberOfPages)-1):
                                    i=k+1
                                    if self.filenamesIds.has_key(id[0]):
                                            filename=self.filenamesIds[id[0]][0]+"_"+self.ids[nr+i]
                                    else:
                                            filename=id[0]

                                    self.response+=str("<p>Get File: %s<br>\n"%filename)

                                    if self.local:
                                            sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+self.ids[nr+i]
                                            targetPath=tmpPath+"/"+filename
                                            try:
                                                    shutil.copyfile(sourcePath,targetPath)
                                        
                                            except:
                                                self.response+=str("<p>Error in File: %s (missing?)<br>\n"%filename)
                                                  
                                    else:

                                            requestString=self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"
                                            path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString

                                            image=urllib.urlopen(path).read()
                                    

                                            fh=file(tmpPath+"/"+filename,"w")
                                            fh.write(image)
                                            fh.close()

        self.response+="<h3>2. step: creating the downloadable file</h3>"
        self.response+="<p>Create gtar<br>"
        self.response+="<p>This can take a while....<br>\n"

        fh=os.popen2("gnutar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
        self.response+="<br>"
        for c in fh.read():
            self.response+=c
            if c==")":
                self.response+="<br>\n"
                    
                            

        
        shutil.rmtree(tmpPath)

        self.response+="<p>finished<br>\n"

        len=os.stat(tmpZip)[6]
        downloadUrl=self.url+"/downloadSet"
        self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
        self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
                    <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)

        self.done=True
    def getResult(self):
        """get result"""
        return self.response

    def isDone(self):
        if self.done:
            return True
        else:
            return False
        
class metaData(SimpleItem):
    """Klasse fuer metadaten"""
    meta_type="metaData"
    
    def __init__(self,xmlurl,container=None):
        """__init__"""
        return self.update(xmlurl,container)


    def update(self,xmlurl,container=None):
        """update"""

        try:
            xmlfh=urllib.urlopen(xmlurl)
            dom=xml.dom.minidom.parse(xmlfh)
        except:
            return None

        md=dom.getElementsByTagName(container)
        mlist=[]
        if md:
            for node in md[0].childNodes:
                if node.nodeType==dom.ELEMENT_NODE:
                    name=node.tagName
                    content=getTextFromNode(node)
                    setattr(self,name,content)
                    mlist.append(name)
            self.mlist=mlist[0:]
        else:
            self.mlist=[]
        
    def index_html(self):
        """index"""
        ret="<html><body>"
        for tag in self.mlist:
            ret+="<p>%s=%s</p>"%(tag,getattr(self,tag))
        return ret+"</body></html>"
                


    
class ImageDigilib(Folder,Persistent,Implicit):
    """Anzeige object fuer digilib"""
    meta_type="ImageDigilib"
    security=ClassSecurityInfo()
    leiden_meta_fields=['image_id','date','country','place','people','description','photographer']

    manage_options = Folder.manage_options+(
        
        {'label':'Add Metadata','action':'addMetaObjectForm'},
        {'label':'View Info','action':'editImageDigilib'},
        )

    def editImageDigilib(self):
        """edit image date"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editImageDigilib.zpt')).__of__(self)
        return pt()        


        
    def getAccessRight(self):
        """get the accessright, return is string "extern" or "intern" """
        return self.getRights(self.filename.split('.')[0])
         
    security.declarePublic('isAccessible')
    
    def isAccessible(self):
        """gives true if obejct is accessible taking the rights of the user into account"""
        logTemp("isaccessible")
        #TODO: implement rights, currently  true if external and false if internal, and true if user has role authenticated
    
        username=self.REQUEST['AUTHENTICATED_USER']
        #print username
        #print self.acl_users.getUserNames()
        user=getSecurityManager().getUser()

        roles=user.getRoles()

        
        if self.getRightsQuery()=="":
            #query empty then always true
            return True


        if 'Authenticated' in roles:
            return True
        
        if self.getAccessRight()=="extern":
            return True
        else:
            return False
        
    def addMetaObject(self,id,RESPONSE=None):
        """Add an MetaObject"""
        objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)

        request=self.REQUEST
        objectCreate=objectType.createObjectManager(id,request)

        self._setObject(id,objectCreate)
        
        objectCreate.propertysheets.meta.manage_editProperties(request)

        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

        


    def addMetaObjectForm(self):
        """Add Form"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetaObject.zpt')).__of__(self)
        return pt()        


    def __init__(self,id,filename,meta=None):
        self.id=id
        self.title=filename
        self.filename=filename
        self.meta=meta

    def getBasename(self):
        """returns base filename (sans extension)"""
        return os.path.splitext(self.filename)[0]

    def getMeta(self):
        """ausgabe der metadaten"""
        return self.meta

    def manageMetaData(self,strict=None):
        """create or updateMetadata"""
        
        md=self.ZopeFind(self,obj_metatypes=["metaData"])
        
        if not md:
            self._setObject("metaData",metaData(self.meta,"ROW"))

        else:
            if not strict:
                md[0][1].update(self.meta,"ROW")
            else:
                print "strict"
                if len(md[0][1].mlist)==0:
                    print " +++",self.getId()
                    md[0][1].update(self.meta,"ROW")
                else:
                    print " ---",self.getId()
                    
    def uploadImage(self,fileupload,path_name):
        """upload an Image from an Requast"""
        #path_name=self.ImageStoragePath
        fn = self.filename or splitPath(fileupload.filename)
        fn = os.path.splitext(fn)[0]+os.path.splitext(fileupload.filename)[1] # Extensions des gespeicherten Files sollte gleich dem hochgeladenen File sein.
        filename=path_name+"/"+fn
        filedata=fileupload.read()
        f=open(filename,"w")
        f.write(filedata)
        f.close()
        self.filename = fn
        
        try:
            os.chmod(filename,0664)
        except:
            """hack"""
        #< thumb
        
        self.scaleThumbs()

        #scale standard

        self.scaleWorkingVersions()

        
        
    def downloadWorkingVersion(self):
            """download working version (2000 pixel)"""
            
            return self.download(fmt="&dw=2000&dh=2000",suffix=".jpg")
    
    def download(self,fmt="&mo=rawfile,hires",suffix=None):
        """download"""
        
        requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt
        path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
        
        
        if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(self.filename):
                filename=self.REQUEST.SESSION['filenamesIds'][self.filename][0]+"_"+self.filename
        else:
                filename=self.filename

        if suffix:
                filename=os.path.splitext(filename)[0]+suffix
                
        self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)
        self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
        #print path
        imagefh=urllib.urlopen(path,'rb')
        
        self.REQUEST.RESPONSE.write(imagefh.read())
        self.REQUEST.RESPONSE.close()
        #return self.REQUEST.RESPONSE.redirect(path)

    def updateImageForm(self):
            """form"""
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateImageForm.zpt')).__of__(self)
            return pt()        


    security.declareProtected('View management screens','renameImageForm')
    def renameImageForm(self):
            """form"""
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','renameImageForm.zpt')).__of__(self)
            return pt()
    
    security.declareProtected('View management screens','renameImage')
    def renameImage(self,newname,RESPONSE=None):
            """umbenennen"""
            #umbennen des files im folder
            oldname=self.getId()
            self.aq_parent.manage_renameObjects(ids=[oldname],new_ids=[newname])
            self.title=newname[0:]
            self.filename=newname[0:]   
            #umbennen des files auf dem server
            oldpath=os.path.join(self.getImageStoragePath(),oldname)
            newpath=os.path.join(self.getImageStoragePath(),newname)
            os.rename(oldpath,newpath)
            
            #umbenennen des versionsfolders
            oldfolder=os.path.join(self.getImageStoragePath(),"."+oldname+".dir")
            newfolder=os.path.join(self.getImageStoragePath(),"."+newname+".dir")
            if os.path.exists(oldfolder):
                os.rename(oldfolder,newfolder)
            else:
                os.mkdir(newfolder)
                
            #schreibe info uber umbennenung

            renameName=os.path.join(newfolder,"renamed")
            if os.path.exists(renameName):
                fh=file(renameName,'a')
            else:
                fh=file(renameName,'w')

            tm=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
            try:
                user=self.REQUEST['AUTHENTICATED_USER']
            except:
                user="unknown"

            str="""%s %s %s %s\n"""%(tm,user,oldname,newname)
            fh.write(str)
            fh.close()
            
            #scale thumb
        
            self.scaleThumbs()
            
            #scale standard

            self.scaleWorkingVersions()

            #self.scaleToJpg()
            if RESPONSE:
                    RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)
        
    def scaleToJpg(self,RESPONSE=None):
        """create a  jpg"""
        
        #create backup of the original file
        
        imagePath=os.path.join(self.getImageStoragePath(),self.filename)
        path=os.path.join(self.getImageStoragePath(),"."+self.getId()+".dir")
                
        if not os.path.exists(path):
            os.mkdir(path,0775)
            os.chmod(path,0775)
            
        newName=os.path.join(path,self.getId()+str(time.time()))

        if os.path.exists(newName):
            logger("ImageArchive:scaleToJpg", logging.INFO, "%s already exists"%newName)
        else:
            try:
                os.rename(imagePath,newName)
            except:
                logger("ImageArchive:scaleToJpg", logging.ERROR, "%s "%newName)
                return False
            
        ext= os.path.splitext(imagePath)[1].lower()
        if ext.rstrip()==".jpg":
                shutil.copy(newName,imagePath)
                print "copy",imagePath
                return True



        dir=self.getId()
        src=path
        self.scale(dest=self.getImageStoragePath(),dir=dir,src=path,scaleBy=1,RESPONSE=RESPONSE)
        return True
    
    def updateImage(self,_fileupload,_rename=None,RESPONSE=None):
        """lade neues Version des Bildes"""
        #teste ob Dokumenten ordner schon vorhanden
        #imagePath=os.path.join(self.getImageStoragePath(),self.getId())
        
        logging.error("updateImage:"+self.filename)
        identifyField="filename"
        
        if _fileupload and _fileupload.filename!="":
            imagePath=os.path.join(self.getImageStoragePath(),self.filename)
            idWithoutSuffix= os.path.splitext(self.getId())[0]
            path=os.path.join(self.getImageStoragePath(),"."+self.getId()+".dir")
                
            if not os.path.exists(path):
                os.mkdir(path,0775)
                os.chmod(path,0775)
                        
            versionNumber=getattr(self,'versionNumber',0)+1
    
            #teste ob version schon existiert
    
            while os.path.exists(os.path.join(path,"V%i_%s"%(versionNumber,self.filename))):
                versionNumber+=1
    
            #kopieren der bestehenden Version in den Versions ordner.
            imageNewPath=os.path.join(path,"V%i_%s"%(versionNumber,self.filename))
            try:    
                    #logger("ImageArchive:updateImage", logging.INFO, "rename: %s -> %s"%(imagePath,imageNewPath))
                    os.rename(imagePath,imageNewPath)
            except:
                logger("ImageArchive:updateImage ", logging.ERROR, "rename: %s -> %s didn't work!"%(imagePath,imageNewPath))      
    
            #lesen des upload files und schreiben
            filedata=_fileupload.read()
            
            #passe suffix an
            oldNameBase=os.path.splitext(imagePath)[0]
            uploadFileExt=os.path.splitext(_fileupload.filename)[1]
            
            newImagePath=oldNameBase+uploadFileExt
            
            f=open(newImagePath,"w") # if we wanted to have filename=id we should do it here!
            logging.error("saving:"+newImagePath)
            f.write(filedata)
            f.close()
            try:
                os.chmod(newImagePath,0664)
            except:
                pass
            #scale thumb
            
            self.scaleThumbs()
                
            #scale standard
    
            self.scaleWorkingVersions()
            #self.scaleToJpg()
            if _rename:
                self.renameImage(_fileupload.filename)
        
            else: 
                self.filename=os.path.splitext(self.filename)[0]+uploadFileExt # Aendere zumindest die Extensiion
     
        try: #todo: sollte nur aufgerufen werden, wenn eine Datenbank dahinter liegt.
            args=self.REQUEST.form
       
            args['-identify']=identifyField+"="+args['_identifyField']
         
            self.ZSQLChange(args=args)
         
        except:
            pass
        
        if RESPONSE:
            RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)
        

        return "done"
  
    security.declarePublic('thumb')
    def thumb(self,url=None):
        """show thumb"""
        thumbname=os.path.splitext(self.filename)[0]+".jpg"
        requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
        path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
    
    
        self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
        if url:
            return "<img border=\"0\" src=\"%s\">"% path
        else:
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self)
            return pt()


    def thumbMD(self,url=None):
        """show thumb mit Metadaten erwarten image in ImageCollectionMD
        """
        thumbname=os.path.splitext(self.filename)[0]+".jpg"
        
        requestString=self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
        path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="+requestString
        

    
        imageString="<img border=\"0\" src=\"%s\">"% path
        self.REQUEST.SESSION['string']=imageString
        if url:
            return "<img border=\"0\" src=\"%s\">"% path
        else:
            
            overview=self.ZopeFind(self.aq_parent,obj_ids=['thumb.html'])
            if overview:
                return getattr(self,overview[0][0])()
            else:
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbMD.zpt')).__of__(self)
                return pt(imageString=imageString)


    def image(self,dw=None,dh=None):
       """show image only with scaler"""
       str=[]
       if (not dw) and (not dh):
           str.append("mo=file")
       if dw:
           str.append("dw=%s"%dw)

       if dh:
           str.append("dw=%s"%dh)
       
       str.append("lv=2&fn=%s"%self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0])
       
       
       requestString="&".join(str)
       
       self.REQUEST.RESPONSE.redirect(getattr(self,'serverPath',genericServerPath)+"/scaledImage?"+requestString)
       
    def index_html(self):
        """show image with zogilib"""
        #DEVELOP: take first one for server
        #path="http://127.0.0.1:8080/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
        path=getattr(self,'serverPath',genericServerPath)+"?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
        return self.REQUEST.RESPONSE.redirect(path)

    
def manage_AddImageDigilibForm(self):
    """Nothing yet"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageDigilibForm.zpt')).__of__(self)
    return pt()
    
def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
    """Add ImageCollection"""
    
    #fileupload=self.REQUEST['fileupload']
    #fn=splitPath(fileupload.filename)
    fn = id # filename is the same as id
    newObj=ImageDigilib(id,fn,meta)
    
    self._setObject(id,newObj)
    getattr(self,id).uploadImage(fileupload,self.getImageStoragePath())
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

                 

class ImageCollection(OrderedFolder, Persistent, Implicit,ECHO_basis):
    """Sammelordner fuer Bilder"""
    meta_type="ImageCollection"


    security=ClassSecurityInfo()
    
    #scalerPath="http://127.0.0.1:18080/digitallibrary/servlet/Scaler/?fn="
    #scalerPath="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="
    
    zipThreads={}
    zipThreads2={}
    
    genericMetaDataType="leiden_meta"

    leiden_meta_fields=['image_id','date','country','place','people','description','photographer']

    
    defaultMetaString="http://fm-web.mpiwg-berlin.mpg.de:8050/FMRes/FMPJS?-db=Wissenschaftlerportraits.fp5&-layID=69&-token=25&-max=1&-format=formvwcss.htm&-mode=browse&images::filename=%s&-find" ## TEST FUER IMAGEDATENBANK WP

    imgcoll_main = PageTemplateFile('zpt/overview', globals())
    imgcoll_mainMD = PageTemplateFile('zpt/overviewMD', globals())
    imgcoll_thumb = PageTemplateFile('zpt/thumb', globals())
    imgcoll_thumbMD = PageTemplateFile('zpt/thumbMD', globals())    

    destBasis="/docuserver/scaled/"
    scaledBasis=destBasis
    srcBasis="/docuserver/images"
    scaleomatStr="/docuserver/libs/scaleomat/scaleomat.pl"
    
    #dest="/Volumes/paviaExtern/docuserver/images/exhibitionImages/"
    
    def configScaleForm(self):
        """configure the scaler form"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','configScale.zpt')).__of__(self)
        return pt()        

    def configScale(self,scaleomatStr,RESPONSE=None):
        """config the scaler"""
        self.scaleomatStr=scaleomatStr
        
            
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def scale(self,dest=None,dir=None,src=None,scaleTo=None,scaleBy=None,RESPONSE=None):
        """scaler"""
        #scaleomatStr="ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl -src=/mpiwg/online/ %s"
        scaleomatStr=self.scaleomatStr

        destBasis=self.destBasis
        srcBasis=self.srcBasis
        
        
        if src:
             srcStr=" -src=%s"%src
        else:
             srcStr=" -src=%s"%srcBasis

        scaleStr=scaleomatStr+srcStr
        if dir:
            dirTmp=dir.replace(srcBasis,'')
            dirStr=" -dir=%s"%dirTmp
            scaleStr=scaleStr+dirStr
        elif filename:
            fileTmp=filename.replace(srcBasis,'')
            fileStr=" -dir=%s"%fileTmp
            scaleStr=scaleStr+fileStr
        else:
            logger("ImageCollection:scale",logging.ERROR,"no directory or filename given")
            return False
        
        if dest is not None:
            destStr=" -dest=%s"%os.path.join(destBasis,dest)
            scaleStr=scaleStr+destStr
        else:
            logger("ImageCollection:scale",logging.ERROR,"no destionation given")
            return False
        
        if scaleTo:
            scaleToStr=" -scaleto=%s"%scaleTo
            scaleStr=scaleStr+scaleToStr
        elif scaleBy:
            scaleByStr=" -scaleby=%s"%scaleBy
            scaleStr=scaleStr+scaleByStr
        else:
            logger("ImageCollection:scale",logging.ERROR,"no destionation given")
            return False
     
       
        #ret=scaleStr
  	    logger("ImageCollection:scale",logging.INFO,scaleStr)
        ret=os.popen2(scaleStr,1)[1].read()
 
        if RESPONSE:
             RESPONSE.write(ret)
        return True
 
    def getImageObject(self,name):
        """gibt objeckt name zurueck"""
        if hasattr(self,name):
            return getattr(self,name)
        
        name=os.path.splitext(name)[0]
        for extension in imageExtensions:
            nameExt=name+extension

            if hasattr(self,nameExt):
                return getattr(self,nameExt)
            
            nameExt=name+"_"+extension
            if hasattr(self,nameExt):
                return getattr(self,nameExt)
        
        return getattr(self,"defaultImg")
        
    def getServerPath(self):
        """get Server path"""
        return getattr(self,'serverPath',genericServerPath)
    
    def getScalerPath(self):
        """get ScalerPath"""
        path=getattr(self,'serverPath',genericServerPath)+"/scaledImage?fn="
    
    def getImageViewerPath(self):
        """get ImageViewerPath"""
        return self.ImageViewerPath

    def getImageStoragePath(self):
        """get ImageStoragePath"""
        if self.ImageViewerPath[0]=="/":
            if len(self.ImageViewerPath)>1:
                iv=self.ImageViewerPath[1:]
            else:
                iv=""
        else:
                iv=self.ImageViewerPath

        return os.path.join(self.srcBasis,iv)
    
    def refreshTxt(self):
        """txt fuer refresh"""
        tn=self.REQUEST.SESSION['threadName']
        return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/createSet",tn)

    def createSet(self,RESPONSE=None,local=None,version="working",repeat=None):
            """download aller gewaehlten files"""

            threadName=repeat
        
                       
            if not threadName or threadName=="":
                threadStart=generateSet(self.REQUEST.SESSION['filenames'],self.REQUEST.SESSION['filenamesIds'],self.ImageViewerPath,self.ImageStoragePath,self.destBasis,self.show_thumbs(),self.absolute_url(),local=local,version=version)
                thread=Thread(target=threadStart)
                
                thread.start()

                    
                self.zipThreads[thread.getName()[0:]]=threadStart
                self.zipThreads2[thread.getName()[0:]]=thread
                self.REQUEST.SESSION['threadName']=thread.getName()[0:]
                wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
                if wait_template:
                    return wait_template[0][1]()
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
                return pt()
                #xmltrans.run()
            else:
                self.REQUEST.SESSION['threadName']=threadName

                if (self.zipThreads[threadName].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','zip_wait.zpt')).__of__(self)
                    return pt()
                else:
                    if self.zipThreads[threadName].isDone():
                        self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
                        self.zipThreads2[threadName].join()
                        del(self.zipThreads2[threadName])
                        del(self.zipThreads[threadName])
                        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
                        return pt()
                        
                    else:
                        self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
                        self.REQUEST.SESSION['threadName']=threadName
                        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
                        return pt()





    def checkThreads(self):
        """teste running threads"""
        ret="""<html>
        <head>
        <meta http-equiv="REFRESH" content="5;url=%s/checkThreads"
        <body><h2>Threads of %s</h2>"""%(self.absolute_url(),self.getId())
        
        for threadName in self.zipThreads.keys():
            if self.zipThreads2[threadName].isAlive():
                ret+="<p>%s --> alive</p>"%threadName
            else:
                ret+="<p>%s --> dead</p>"%threadName
        return ret+"</body></html>"
    
    def downloadSet(self,fn):
            """download prepared set"""
            filename=os.path.join(tdir,fn)

            
            self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.tgz")
            self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
            len=os.stat(filename)[6]
            self.REQUEST.RESPONSE.setHeader("Content-Length",len)
            images=file(filename).read()
            self.REQUEST.RESPONSE.write(images)
            self.REQUEST.RESPONSE.close()

       
    def scaleToJpgs(self,RESPONSE=None):
        """scale all tifs to jps"""

        for x in self._objects:
                
                if (not hasattr(getattr(self,x['id']),'scaleToJpg')) or (not getattr(self,x['id']).scaleToJpg()):
                    if RESPONSE:
                        RESPONSE.write('error:%s'%x)
                
                
                    
    def scaleThumbs(self,RESPONSE=None):
        """scale thumbs"""
        
        #scale thumbs
        dest=os.path.join(self.scaledBasis,'thumb')
        self.scale(dir=self.getImageStoragePath(),dest=dest,scaleTo=100,RESPONSE=RESPONSE)
        #ret=os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl -src=/mpiwg/online/ -dir=%s -dest=/mpiwg/temp/online/scaled/thumb -scaleto=100 &"% self.ImageViewerPath)
        #if RESPONSE:
        #        RESPONSE.write(ret.read())
        #        RESPONSE.write("\n")
                
        return "RESCALING STARTED"

    def scaleWorkingVersions(self,RESPONSE=None):
        """scale working versions"""
        
        #scale standard
       
        dest=os.path.join(self.scaledBasis,'small')
        self.scale(dir=self.getImageStoragePath(),dest=dest,scaleTo=1000,RESPONSE=RESPONSE)
        
        dest=os.path.join(self.scaledBasis,'medium')
        self.scale(dir=self.getImageStoragePath(),dest=dest,scaleTo=2000,RESPONSE=RESPONSE)
       
        #ret=os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl -src=/mpiwg/online/ -dir=%s -dest=/mpiwg/temp/online/scaled/small -scaleto=2000 &"% self.ImageViewerPath)
        if RESPONSE:
                RESPONSE.write(ret.read())
                RESPONSE.write("\n")
        return "rescaling started"

    
    def __init__(self,id,title,ImageViewerPath,defaultMetaString,destBasis,srcBasis,serverPath=genericServerPath):
        self.id=id
        self.title=title
        self.ImageViewerPath=ImageViewerPath
        self.defaultMetaString=defaultMetaString
        self.serverPath=serverPath
        self.destBasis=destBasis
        self.srcBasis=srcBasis
        self.defaultrows = 6
        self.defaultcols = 2

    optTMP= Folder.manage_options

    manage_options = optTMP+(
        {'label':'Main Config','action':'ImageCollection_config'},
        {'label':'Config Scaler','action':'configScaleForm'},
        {'label':'Import','action':'ImportFiles'},
        {'label':'Recalculate MetadataLink','action':'recalculateMetaLink'},
        {'label':'Import Metadata File','action':'importMetaFileForm'},
        {'label':'Import Metadata','action':'importMetaData'},
        {'label':'Rescale thumbs','action':'scaleThumbs'},
        {'label':'Rescale working version','action':'scaleWorkingVersions'},
        )

    

    def importMetaData(self,strict=None):
        """import metadata, if strict ist not None then only metadata will be rebuild where metadata is empty"""
        
        for image in self.ZopeFind(self,obj_metatypes=["ImageDigilib"]):
           
            image[1].manageMetaData(strict)
        return "ok"
        

    def importMetaFileForm(self):
        """import metadata"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importMeta.zpt')).__of__(self)
        return pt()

    def importMetaFile(self,fileupload,tag):
        """import"""
        filedata=fileupload.read()
        dom=xml.dom.minidom.parseString(filedata)
        rows=dom.getElementsByTagName(tag)
        #print "ROWS",rows
        request=self.REQUEST
        for row in rows:
            
            for a in self.leiden_meta_fields:
                self.REQUEST[a]=getText(row.getElementsByTagName(a)[0].childNodes)

            image_id=self.REQUEST['image_id']
            if (not hasattr(self,image_id)) & (not image_id==""):
                #print image_id
                newObj=ImageCollection(str(image_id),image_id,'','','')
                self._setObject(str(image_id),newObj)

            id="leiden_meta_data_file"
            self.REQUEST['id']=id
            #objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
            #objectCreate=objectType.createInObjectManager(id,request)
            #href="http://localhost:8080/tests/testcollection/manage_addProduct/ImageMetaData/leiden_meta_factory/"
            try:
                addID=getattr(self,image_id)
                objectCreate=addID.manage_addProduct['ImageMetaData'].leiden_meta_add(id)
                #getattr(self,image_id)._setObject(id,objectCreate)
                obj=getattr(addID,id)
                obj.propertysheets.meta.manage_editProperties(request)
            except:
                """nothing"""
        return "OK"
    

    def nextImage(self,request,selected=None,returnFn=None):
        """show nextimage"""
        try:
            ids=self.show_thumbs()
            if request.SESSION.has_key("filename"):
                filename=request.SESSION["filename"]
                try:
                    nr=ids.index(filename)
                  
                except:
                    nr=0
            else:
                nr=0

            if nr==len(ids)-1:
                    return ""
            else:
                if returnFn:
                            return ids[nr+1]
                    
                if selected:
                    return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
                else:
                    return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
        except:
            return ""
        
    def prevImage(self,request,selected=None):
        """show nextimage"""
        #return self.getId()
        try:
            ids=self.show_thumbs()
            if request.SESSION.has_key("filename"):
                filename=request.SESSION["filename"]
                try:
                    nr=ids.index(filename)
                except:
                    nr=0
            else:
                nr=0

            if nr==0:
                return ""
            else:
                if selected:
                    return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
                else:
                    return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
        except:
            return ""
        
    def meta_default(self,filename):
        """url der metadaten"""
        return self.defaultMetaString % urllib.quote(filename)
                     
    def getThumbAttribute(self,id,attr):
        if hasattr(self,id):
            return getattr(getattr(self,id),attr)
        else:
            if attr=='title':
                return "<b>Missing Image:%s</b>" % id

    def getThumbFunction(self,id,attr):
        #return "DUMP"
        if hasattr(self,id):
            return getattr(getattr(self,id),attr)()
        
            
    def xmlinput(self,url):
        """Anzeige von ausgewaehlten thumbs"""
        #return url
        
        url=urllib.unquote(url)
        xmldoc=urllib.urlopen(url).read()
        #return xmldoc
        try:
                dom=xml.dom.minidom.parseString(xmldoc)
        except:
                return "ERROR: (%s %s) %s"%(sys.exc_info()[0],sys.exc_info()[1],xmldoc)

        images=dom.getElementsByTagName('image')

        rc=[]
        fnIds={}
        for image in images:
                imagename=image.getElementsByTagName('imagename')[0]
              
                
                
                
                idnr=image.getElementsByTagName('idnr')[0]
                id=getText(idnr.childNodes)
                try:
                    numberOfPages=image.getElementsByTagName('numberOfPages')[0]
                except:
                    numberOfPages=None
                    
                if numberOfPages:
                    nopT=getText(numberOfPages.childNodes)
                    try:
                            nop=int(nopT)
                    except:
                            nop=0
                else:
                    nop=0
                            
                texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
                for text in texts:
                    if not text=="":
                        text=self.getImageByName(text,onlyName="yes")
                        try:
                                rc.append((str(text),id,nop))
                                fnIds[str(text)]=(id,nop)
                        except:
                                rc.append((repr(text),id,nop))
                                fnIds[repr(text)]=(id,nop)
                

        rc.sort()
        self.REQUEST.SESSION['filenames']=rc
        self.REQUEST.SESSION['filenamesIds']=fnIds
        
        overview=self.ZopeFind(self,obj_ids=['overview_selected.html'])
            
        if overview:
                return overview[0][1]()
        else:
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
                return pt()        
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
        return pt()        

    def recalculateMetaLink(self):
        """recalculate the metadata"""
        
        for entryid in self.__dict__:
            entry=getattr(self,entryid)
            if hasattr(entry,'meta_type'):
                
                if entry.meta_type=="ImageDigilib":
                    entry.meta=entry.meta_default(entry.getId())
        return "OK"
    
    def addImage(self):
        """Add an Image"""
                
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self)
        return pt()
    
    def addImage2(self,fileupload,fileName=None,meta=None,use_default=None,RESPONSE=None):
        """Add"""

        #print "FU",fileupload

        if use_default:
            try:
                meta=self.meta_default(fileupload.filename)
            except:
                meta=None
        else:
            meta=None
        
        fn=fileName or splitPath(fileupload.filename)
        
        manage_AddImageDigilib(self,fn,fileupload,meta=meta)
        
        if RESPONSE:
            return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
        #return  self.REQUEST['URL1']+'/'+fileupload.filename

    def ImportFiles2(self,RESPONSE=None):
        """Import the existing files of a folder"""
        files=os.listdir(self.getImageStoragePath())
        ret=""
        #print self.__dict__
        for file in files:
            fn=os.path.splitext(file)[0]
            if not (file[0]=="."):
                if self.__dict__.has_key(file) or self.__dict__.has_key(fn+'.tif') or self.__dict__.has_key(fn+'.tiff') :

                    ret=ret+"<br>"+file+" already exists!"
                else:
                    ret=ret+"<br>"+file+" created!"
                    meta=self.meta_default(file)
                    newObj=ImageDigilib(file,file,meta)
                    #print newObj,file
                    #print newObj
                    self._setObject(file,newObj)
        #print ret
        #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
        #print self.getImageStoragePath()

        #scale thumb
        
        self.scaleThumbs()

        #scale standard

        self.scaleWorkingVersions()
        

        RESPONSE.redirect('manage_main')

    ## def importStructure(self,path):
##         """import"""
##         splitted=os.path.split(path)
##         if os.path.isDir(path) and (len(splitted[1])>0) and (splitted[1][0]=="."):
##             manage_AddImageCollection(self,splitted[1],splitted[1],path,self.ImageViewerPath,self.defaultMetaString,RESPONSE=None)
            
##             obj=getattr(self,splitted[1])
##             obj.ImportFiles()

    def ImportStructure(self,RESPONSE=None):
        """Import the existing files of a folder"""
        files=os.listdir(self.getImageStoragePath())
        ret=""
        #print self.__dict__


        for file in files:
            
            if os.path.isdir(os.path.join(self.getImageStoragePath(),file)):
                ImageStoragePath=os.path.join(self.getImageStoragePath(),file)
                imageViewerPath=os.path.join(self.ImageViewerPath,file)
                manage_AddImageCollection(self,file,file,self.getImageStoragePath(),imageViewerPath,self.defaultMetaString)
            
                obj=getattr(self,file)
                obj.ImportStructure()
            else:
                if not file[0]==".":
                    if self.__dict__.has_key(file):

                        ret=ret+"<br>"+file+" already exists!"
                    else:
                        ret=ret+"<br>"+file+" created!"
                        newObj=ImageDigilib(file,file)
                        #print newObj,file
                        #print newObj
                        try:
                            self._setObject(file,newObj)
                        except:
                            """nothing yet"""
        #print ret
        #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
        #print self.getImageStoragePath()

                #scale thumb
        
        self.scaleThumbs()

        #scale standard

        self.scaleWorkingVersions()
        
        if RESPONSE:
                RESPONSE.redirect('manage_main')
    
    def ImportFiles(self,RESPONSE=None):
        """Import the existing files of a folder"""
        files=os.listdir(self.getImageStoragePath())
        ret=""
        #print self.__dict__
        for file in files:
            fn=os.path.splitext(file)[0]
            if not (file[0]=="."):
                if self.__dict__.has_key(file) or self.__dict__.has_key(fn+'.tif') or self.__dict__.has_key(fn+'.tiff') :

                    ret=ret+"<br>"+file+" already exists!"

                else:
                    ret=ret+"<br>"+file+" created!"
                    newObj=ImageDigilib(file,file)
                    #print newObj,file
                    #print newObj
                    try:
                        self._setObject(file,newObj)
                    except:
                        """nothing yet"""
        #print ret
        #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
        #print self.getImageStoragePath()

                #scale thumb
        
        self.scaleThumbs()

        #scale standard

        self.scaleWorkingVersions()
        
        if RESPONSE:
                RESPONSE.redirect('manage_main')
        
    def ImageCollection_config(self):
        """Nothing yet"""
        if not hasattr(self,'defaultMetaString'):
            self.defaultMetaString=""
            
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeImageCollectionForm.zpt')).__of__(self)
        return pt()

    def ChangeImageCollection(self,title,ImageViewerPath,defaultMetaString,serverPath,destBasis,srcBasis,RESPONSE=None):
        """Change"""
        self.title=title
        self.ImageViewerPath=ImageViewerPath
        self.defaultMetaString=defaultMetaString
        self.serverPath=serverPath
        self.destBasis=destBasis
        self.srcBasis=srcBasis
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def show_selected_thumbs(self):
        #ids=[]
        try:
         return self.REQUEST.SESSION['filenames']
        except:
         return None
    def show_thumbs(self):
        ids=[]
        for entry in self.__dict__:
            #print entry
            if hasattr(getattr(self,entry),'thumb'):
                ids.append(entry)
                
        #print ids
        ids.sort()
        return ids

    def firstSets(self,selected=None,text='first set'):
        ids=self.show_thumbs()
        if ids:
            if selected:
                return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">"+text+"</a>"
            else:
                return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">"+text+"</a>"

    def lastSets(self,selected=None,text='last set'):
        ids=self.show_thumbs()
        if ids:
            colRows=self.getColTimesRow()

            if colRows[1]:
                nr=len(ids)-colRows[0]*colRows[1]
            else:
                nr=0

            if nr<0:
                nr=0

            if selected:
                return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
            else:
                return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"

        
                
    def nextSets(self,selected=None,text='next set'):
        """show nextimage"""
        ids=self.show_thumbs()
        colRows=self.getColTimesRow()
        pagesize = colRows[0] * colRows[1]
        if ids:
            if colRows[1]:
                if self.REQUEST.SESSION.has_key("filename"):
                    filename=self.REQUEST.SESSION["filename"]
                    try:
                        nr=ids.index(filename)+pagesize
                        if nr>=len(ids):
                            return ""
                    except:
                        nr=pagesize
                else:
                    nr = pagesize

                if nr>=len(ids)-1:
                    return ""
                else:
                    if selected:
                        return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
                    else:
                        return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"

    def prevSets(self,selected=None,text='previous sets'):
        
        """show nextimage"""
        #return self.getId()
        ids=self.show_thumbs()
        colRows=self.getColTimesRow()
        if ids:
            if colRows[1]:
                if self.REQUEST.SESSION.has_key("filename"):
                    filename=self.REQUEST.SESSION["filename"]
                    try:
                        nr=ids.index(filename)-colRows[0]*colRows[1]
                        if nr<0:
                            nr=0
                    except:
                        nr=0
                else:
                    nr=0
                try:
                    num=ids.index(filename)
                except:
                    num=0

                if num==0:
                    return ""
                else:
                    if selected:
                        return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
                    else:
                        return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">"+text+"</a>"
            else:
                return ""


    def showFolders(self):
        """show subfolders"""
        ret=""
        link=""" <a target="_top" href="%s">%s</a><br>"""

        if self.aq_parent.meta_type=="ImageCollection":
            ret+=link%(self.aq_parent.absolute_url(), "back ("+self.aq_parent.title+")")
            ret+="<br>"
            
        iCs=self.ZopeFind(self,obj_metatypes=["ImageCollection"])
        if not iCs:
            return ret
        else:
            
            link=""" <a target="_top" href="%s">%s</a><br>"""
            for iC in iCs:
                ret+=link%(iC[1].absolute_url(),iC[0])
            ret+="<br>"
            return ret


    def getSetSelector(self, selected=None):
        """returns the HTML select element for the sets"""
        actualNr=0
        ids=self.show_thumbs()
        colRows=self.getColTimesRow()
        pagesize = colRows[0]*colRows[1]
        numpages = int(len(ids)/pagesize)
        if not ((len(ids) % pagesize)==0):
            numpages+=1
    
        ret=""
        if numpages>1:
            if selected:
                ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""/selection?filename='+this.options[this.selectedIndex].value">"""
            else:
                ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""?filename='+this.options[this.selectedIndex].value">"""
                
            for i in range(numpages):
                try:
                  nr=ids.index(self.REQUEST.SESSION['filename'])
                except:
                  nr=0
                k=i * pagesize
                if (k <= nr) and (nr < i*(pagesize+1)):
                   actualNr=i
                   ret+="""<option value="%s" selected>%i</option>"""%(ids[k], i + 1)
                else:
                   ret+="""<option value="%s">%i</option>"""%(ids[k], i + 1)
                   
            ret+="</select>"
            
        return ret

    def isAllSets(self, showall=None):
        """returns if there are any sets"""
        ids=self.show_thumbs()
        colRows=self.getColTimesRow(showall=showall)
        pagesize = colRows[0]*colRows[1]
        return (len(ids) <= pagesize)
        

    def allSets(self, texton='show all', textoff='show groups'):
        """returns HTML to toggle 'show all'"""
        if self.isAllSets(showall='No'):
            return ""
        showall=self.REQUEST.SESSION.get('showall','no')
        if showall=='no':
            ret='<a href="'+self.REQUEST['URL1']+'?showall=yes" target="_top">'+texton+'</a>'
        else:
            ret='<a href="'+self.REQUEST['URL1']+'?showall=no" target="_top">'+textoff+'</a>'
        return ret


    def showRuler(self,selected=None):
        """show ruler"""
        showall=self.REQUEST.SESSION.get('showall','no')
        ids=self.show_thumbs()
        if len(ids)==0:
            return "<b>No entries</b>"
        
        if showall=='no':
            actualNr=0
            ids=self.show_thumbs()
            colRows=self.getColTimesRow()
            num=int(len(ids)/(colRows[0]*colRows[1]))
            if not (operator.mod(len(ids),colRows[0]*colRows[1])==0):
                num+=1
            a=colRows[0]*colRows[1]
            #print num,num+1
                
            if num>1:

                ret=""
                if selected:
                        ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""/selection?filename='+this.options[this.selectedIndex].value">"""
                else:
                        ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""?filename='+this.options[this.selectedIndex].value">"""
                for i in range(num):
                        try:
                          nr=ids.index(self.REQUEST.SESSION['filename'])
                        except:
                          nr=0
                        k=i*a   
                        if (k <= nr) and (nr < i*(a+1)):
                           actualNr=i
                           ret+="""<option value="%s" selected>%i</option>"""%(ids[k],i)
                        else:
                           ret+="""<option value="%s">%i</option>"""%(ids[k],i)
                ret+="</select>"        
                anf="<b>Show thumbnail group no: </b></br>"
                
                
                try:
                  if selected:                
                        href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr-1)*a]
                  else:
                        href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr-1)*a)]
                
                  anf+="""<a href="%s" target="_top">%s</a>&nbsp;&nbsp;"""%(href,"prev")
                except:
                  pass
                ret=anf+ret
                
                try:
                  
                  if selected:                
                        href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr+1)*a]
                  else:
                        href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr+1)*a)]
                
                  end="""<a href="%s" target="_top">%s</a>&nbsp;&nbsp;"""%(href,"next")
                except:
                  end=""
                ret=ret+end


                #for i in range(num):
                #    
                #        ret +="<br/>" #alle 10 linebreak einfuegen
                #    k=i*a
                #    if selected:                
                #        href=self.REQUEST['URL1']+"/selection?filename="+ids[k]
                #    else:
                #        href=self.REQUEST['URL1']+"?filename="+ids[int(k)]
                #
                #    ret+="""<a href="%s" target="_top">%i</a>&nbsp;&nbsp;"""%(href,i)

            else:
                ret=""
            ret+="""<a href="%s?showall=yes" target="_top">show all</a> """%self.REQUEST['URL1']
        else:
            ret="""<a href="%s?showall=no" target="_top">show groups</a> """%self.REQUEST['URL1']

        return ret

    
    def show_thumbs_selected_rows(self,numberOfColumns,start=0,max=10000):
        """Ausgabe anzahl"""
        ids=self.show_selected_thumbs()

        if not ids:
                return None
        self.REQUEST.SESSION['ids']=ids
        number=min(start+int(len(ids)/numberOfColumns)+1,max)
        
        self.REQUEST.SESSION['number']=range(start,number)
        return range(start,number+1)

    def setColTimesRowForm(self):
        """form for matrix setting"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','selectColTimesRow.zpt')).__of__(self)
        return pt()

    def setDone(self):
        """done"""
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changedColTimesRow.zpt')).__of__(self)
        return pt()

    def setColTimesRow(self,cols,rows):
        """set coltimes row"""
        RESPONSE=self.REQUEST.RESPONSE
        if not rows:
            rows=None
        if rows=="":
            rows=None

        if rows:
            RESPONSE.setCookie("ImageViewerRows",rows)
        RESPONSE.setCookie("ImageViewerCols",cols)

        RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")

    def setDefaultColTimesRow(self, cols, rows):
        """sets default columns and rows"""
        self.defaultcols = cols
        self.defaultrows = rows

    def getColTimesRow(self,showall='No'):
        """coltimesrow"""
        
        REQUEST=self.REQUEST
        """matrix"""
        if REQUEST.cookies.has_key("ImageViewerRows"):
            try:
                rows=int(REQUEST.cookies["ImageViewerRows"])
            except:
                rows=getattr(self,'defaultrows',6)
        else:
            rows=getattr(self,'defaultrows',6)
            
        if REQUEST.cookies.has_key("ImageViewerCols"):
            #print "COLS",REQUEST.cookies["ImageViewerCols"]
            cols=int(REQUEST.cookies["ImageViewerCols"])
        else:
            cols=getattr(self,'defaultcols',3)


        idsnumber=len(self.show_thumbs())
        if rows:
            if cols*rows >idsnumber:
                rows=int(idsnumber/cols)+1

        if showall is None:
            showall=self.REQUEST.SESSION.get('showall', 'No')
        if showall=='yes':
            rows=int(idsnumber/cols)+1
        
        logTime("getColTimesRow finished")
        return (cols,rows)
                
        
    def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None,showall="No"):
        """Ausgabe anzahl"""

        idsAll=self.show_thumbs()
        if len(idsAll)==0: #keine Eintraege
            return 0
        if self.REQUEST.SESSION.has_key("filename") and not (showall=="yes"):
            filename=self.REQUEST.SESSION["filename"]
            filename=self.getImageByName(filename,onlyName="yes")
                
            try:
                startId=filename
                if startId=="":
                    startId=idsAll[0][0:]    
            except:
                startId=idsAll[0][0:]    
        else:
            startId=idsAll[0][0:]
            

        

        if numberOfRows:
           
            startPic=idsAll.index(startId)
            try:
                
                startPic=idsAll.index(startId)
                endPic=startPic+numberOfColumns*numberOfRows
                ids=idsAll[startPic:endPic]
            except:
                ids=idsAll
        else:

            ids=idsAll

          
        self.REQUEST.SESSION['ids']=ids
        number=int(len(ids)/numberOfColumns)+1
        
        logTime("show_thumbs_rows finished (%s)"%str(number))
        return range(number+1)

    def show_thumbs_columns(self,row,numberOfColumns):
        """Ausgabe einer Liste der Reihe"""
        ids=self.REQUEST.SESSION['ids']
        max=len(ids)
        logTime("show_thumb_columns finishes row: %s"%row)
        if (row*numberOfColumns)<max:
            return ids[(row-1)*numberOfColumns:row*numberOfColumns]
        else:
            return ids[(row-1)*numberOfColumns:]
        

    def thumblistSelected(self):
        """main template collection"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected2.zpt')).__of__(self)
        return pt()
    

    def thumblist(self):
        """main template collection"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb2.zpt')).__of__(self)
        return pt()

    def thumblistNewWindow(self):
        """Thumbs mit clik neues Fenster oeffnen"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbNewWindow.zpt')).__of__(self)
        return pt()
        

    def navig_selected_html(self):
        """navigation"""
        #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selected.zpt')).__of__(self)

        return pt().data

    def navig_html(self):
        """navigation"""
        #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
       
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation.zpt')).__of__(self)
        return pt()


    def selection(self):
        """show only selected"""
        if self.REQUEST.has_key('filename'):
            filen=self.REQUEST['filename']
        else:
            filen=""
        self.REQUEST.SESSION['filename']=filen
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected2.zpt')).__of__(self)
        return pt()  

    def getImageByName(self,filename,onlyName=None):
        """get filename"""
        #print repr(filename)
        #FIXME: umlaute in filename
        fn=getattr(self,repr(filename),None)
        if not fn:

	    if os.path.splitext(filename)[1].lower() in imageExtensions:
	            filenameM=os.path.splitext(filename)[0]
            else:                    
		   filenameM=filename



            founds=self.ZopeFind(self,obj_metatypes=['ImageDigilib'])

	    
            for found in founds:
		if os.path.splitext(found[0])[1].lower() in imageExtensions:
	                foundM=os.path.splitext(found[0])[0]
		else:	
			foundM=found[0]

                if filenameM.lower()==foundM.lower():
                    if onlyName:
                        return found[0]
                    else:
                        return found[1]   
                #HACK teste noch ob am ende des filenames eventuell ein "_" und loesche das.    
                if foundM[-1]=="_":
                    foundM=foundM[0:-1]

                    if filenameM.lower()==foundM.lower():
                        if onlyName:
                            return found[0]
                        else:
                            return found[1]   
                
        if onlyName:
            return filename
        else:
            return fn
        
        
    security.declareProtected('View','index_html')
    def index_html(self,fn=None,generic='No'):
        """main template collection"""

        if fn:
            ret=[]

            if type(fn) is ListType:
                """experimentell mehr als ein filename"""
                for filename in fn:
                    if not (filename == ""):
                        ret.append((filename,'',1))
            else:
                ret.append((fn,'',1))

            self.REQUEST.SESSION['filenames']=ret
                #self.REQUEST.SESSION['filenamesIds']=fnIds
          
            overview=self.ZopeFind(self,obj_ids=['overview_selected.html'])
            

            if overview and (generic =='No'):
                return overview[0][1]()
            else:
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
                return pt()        

        if self.REQUEST.has_key('filename'):
            filen=self.REQUEST['filename']
        else:
            filen=""

        self.REQUEST.SESSION['filename']=filen[0:]

        if self.REQUEST.has_key('showall'):

            self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
        else:
            self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
            

        overview=self.ZopeFind(self,obj_ids=['overview.html'])
        if overview and (generic == 'No'):
            return overview[0][1]()
        elif hasattr(self,'templates'):
            pt=self.templates.imgcoll_main.__of__(self)
            return pt()
        else:
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__of__(self)
            return pt()
        
    def navigation(self):
        """generate navigation bar"""
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_fragment')).__of__(self)
        return pt()    
    
def manage_AddImageCollectionForm(self):
    """Nothing yet"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionForm.zpt')).__of__(self)
    return pt()
    
def manage_AddImageCollection(self,id,title,ImageViewerPath,defaultMetaString,destBasis,srcBasis,serverPath,RESPONSE=None):

    """Add ImageCollection"""
    newObj=ImageCollection(id,title,ImageViewerPath,defaultMetaString,destBasis,srcBasis,serverPath=genericServerPath)
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


  
class ImageCollectionMD(ImageCollection,ZSQLExtendFolder):
    """Imageviewer and Metadata"""
    meta_type="ImageCollection MD"
    #scalerPath="http://127.0.0.1:18080/digitallibrary/servlet/Scaler/?fn="
    scalerPath="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="
    rightsQueryDefault="SELECT accessibility from vision_main where id_image=(SELECT id from vision_images where filename ~ '%s*' )"
    rightsQueryFieldDefault="accessibility"
    
    manage_options=ImageCollection.manage_options+(
        {'label':'ZSQLExtend','action':'changeZSQLExtendForm'},
        {'label':'Change Rights Query','action':'changeRightsQueryForm'},
       )

    try:        
        changeZSQLExtendForm=ZSQLExtendFolder.changeZSQLExtendForm
    except:
        pass
    
    
    def ImportFiles(self,RESPONSE=None):
        """Import the existing files of a folder"""
        files=os.listdir(self.getImageStoragePath())
        ret=""
        #print self.__dict__
        for file in files:

            if not (file[0]=="."):
                fn=os.path.splitext(file)[0]
                if self.__dict__.has_key(file) or self.__dict__.has_key(fn+'.tif') or self.__dict__.has_key(fn+'.tiff') :

                    ret=ret+"<br>"+file+" already exists!"

                else:
                    logger("ImageArchiveMD:import", logging.INFO, "adding ZOPE: %s"%file)
                    ret=ret+"<br>"+file+" created!"
                    newObj=ImageDigilib(file,file)
                    #print newObj,file
                    #print newObj
                    try:
                        self._setObject(file,newObj)
                    except:
                        """nothing yet"""
                        
                # check entry in database
                args={}
                args['_table']=self.imageCollectionConfig.getTable()
                args[self.imageCollectionConfig.getKey()]=file

                if not self.ZSQLInline(args=args):
                    logger("ImageArchiveMD:import", logging.INFO, "adding DB: %s"%file)
                    self.ZSQLAdd(args=args)
 
        #print ret
        #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
        #print self.ImageStoragePath

                #scale thumb
        
        
        self.scaleThumbs()

        #scale standard

        self.scaleWorkingVersions()
        
        #self.scaleToJpgs()
        
        if RESPONSE:
                RESPONSE.redirect('manage_main')
  
    def addImage(self):
        """Add an Image"""
                
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImageMD.zpt')).__of__(self)
        return pt()
    
    def addImage2(self,_fileupload,_fileName=None,_meta=None,_use_default=None,RESPONSE=None):
        """Add"""

        filenameKey="filename"
        #print "FU",fileupload

        if _use_default:
            try:
                meta=self.meta_default(_fileupload.filename)
            except:
                meta=None
        else:
            meta=None
        
        fn=_fileName or splitPath(_fileupload.filename)
        
        manage_AddImageDigilib(self,fn,_fileupload,meta=meta)
        
        args=self.REQUEST.form
        args[filenameKey]=fn
        
        self.ZSQLAdd(args=args)
        
        self.scaleThumbs()
        self.scaleWorkingVersions()
        
        getattr(self,fn).scaleToJpg()
        if RESPONSE:
            return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
        #return  self.REQUEST['URL1']+'/'+fileupload.filename

    def navig_html(self):
        """navigation"""
        #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
       
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigationMD.zpt')).__of__(self)
        return pt()
        
    def navig_selected_html(self):
        """navigation"""
        #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selectedMD.zpt')).__of__(self)

        return pt()

    def decode(self,str):
        """decoder"""
        if not str:
            return ""
        if type(str) is StringType:
            try:            
                return str.decode('utf-8')
            except:
                return str.decode('latin-1')
        else:
            
            return str

    def standardSearch(self):
        """standard search page"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','standardSearchPage.zpt')).__of__(self)
        return pt()        
        
    def searchResultXML(self):
        """xmlformat"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultXML.zpt')).__of__(self)
        return pt()        

    def searchDB(self,REQUEST=None,RESPONSE=None,xml=None):
        """search"""
        
        rc=[]
        fnIds={}

        for found in self.ZSQLInlineSearch(args=self.REQUEST.form):
            key=getattr(found,self.imageCollectionConfig.getKey())
            key=self.getImageByName(key,onlyName="yes")        
            rc.append((key,'',0))
            fnIds[key]=('',0)
                
        rc.sort()
        self.REQUEST.SESSION['filenames']=rc
        self.REQUEST.SESSION['filenamesIds']=fnIds
        
        overview=self.ZopeFind(self,obj_ids=['overview_selectedMD.html'])
            
        if overview:
                return overview[0][1]()
        else:
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
                return pt()        
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
        return pt()        
        
        #urlTmp=REQUEST['URL1']
        
        #url=urlTmp+'/searchResultXML?-table=%s&'%self.imageCollectionConfig.getTable()+REQUEST['QUERY_STRING']
        
        #if xml is None:
        #    RESPONSE.redirect('xmlinput?url='+urllib.quote(url))
        #else:
        #    RESPONSE.redirect(url)
            
    def index_html(self,fn=None,selection=None,generic='No',REQUEST=None,RESPONSE=None):
        """main template collection"""

        logTime("index_html %s"%self.REQUEST['QUERY_STRING'])
        mode=self.REQUEST.get('mode','view')
        if fn:
            ret=[]

            if type(fn) is ListType:
                """experimentell mehr als ein filename"""
                for filename in fn:
                    if not (filename == ""):
                        ret.append((filename,'',1))
            else:
                ret.append((fn,'',1))

            self.REQUEST.SESSION['filenames']=ret
                #self.REQUEST.SESSION['filenamesIds']=fnIds
          
            overview=self.ZopeFind(self,obj_ids=['overview_selected.html'])
            

            if overview and (generic =='No'):
                return overview[0][1]()
            else:
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
                return pt()        

        
        # filename given, then only display this file
        if self.REQUEST.has_key('filename'):

            filen=self.REQUEST['filename']
        else:
            filen=""


        self.REQUEST.SESSION['filename']=filen[0:]
        
#        if not self.REQUEST.SESSION['filename']=="":
#            url=getattr(self.getImageByName(self.REQUEST.SESSION['filename']),'absolute_url')()
#            if mode=="view":
#                self.REQUEST.RESPONSE.redirect(url)
#            elif mode=="download":
#                self.REQUEST.RESPONSE.redirect(url+"/download")
#                
        if self.REQUEST.has_key('showall'):

            self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
        else:
            self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
            
            
        if selection:
            #selection i.e. selection already stored at self.REQUEST.SESSION['filenames']
            overview=self.ZopeFind(self,obj_ids=['overview_selected.html'])
            

            if overview and (generic =='No'):#
              
                return overview[0][1]()
            else:
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
                return pt()   
            
            
        #no filename then show overview

        overview=self.ZopeFind(self,obj_ids=['overview.html'])
        if overview and (generic == 'No'):

          
            return overview[0][1]()
        elif hasattr(self,'templates'):
          
            pt=self.templates.imgcoll_mainMD.__of__(self)
            return pt()
        else:
          
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overviewMD.zpt')).__of__(self)
            return pt()
        
    def nextImage(self,request,selected=None,returnFn=None):
        """show nextimage"""
    
        if not selected and self.REQUEST.has_key('fn'):
            imagename=self.REQUEST['fn'].split('/')[-1]
            
            imagename=self.getImageByName(imagename,onlyName=True)
            
            nr=self.getObjectPosition(imagename)
    
            objects=self.objectIds()
            if len(objects)==nr+1:
                return ""
            else:
                fn="/".join(self.REQUEST['fn'].split('/')[0:-1])+"/"+objects[nr+1]
                return "<a href=\""+self.REQUEST['URL0']+"?fn="+fn+"\" target=\"_top\">next image</a>"                

    def prevImage(self,request,selected=None,returnFn=None):
        """show nextimage"""
    
        if not selected and self.REQUEST.has_key('fn'):
            imagename=self.REQUEST['fn'].split('/')[-1]
            
            imagename=self.getImageByName(imagename,onlyName=True)
            
            nr=self.getObjectPosition(imagename)
    
            objects=self.objectIds()
            if nr==0:
                return ""
            else:
                fn="/".join(self.REQUEST['fn'].split('/')[0:-1])+"/"+objects[nr-1]
                return "<a href=\""+self.REQUEST['URL0']+"?fn="+fn+"\" target=\"_top\">prev image</a>"                
    
        
    def changeRightsQueryForm(self):
        """change Rights Query"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeRightsQueryForm.zpt')).__of__(self)
        return pt()
  
    def changeRightsQuery(self,rightsQuery,rightsQueryField,RESPONSE=None):
        """change Rightsquery"""
        
        self.rightsQuery=rightsQuery
        self.rightsQueryField=rightsQueryField
        
        if RESPONSE is not None:
                RESPONSE.redirect('manage_main')

    
        
    def getRightsQuery(self):
        """get Query"""
        return getattr(self,'rightsQuery',self.rightsQueryDefault)
    
    def getRightsQueryField(self):
        """get Query Fiueld"""
        return getattr(self,'rightsQueryField',self.rightsQueryFieldDefault)
    
    
    
    def setGenericSearchStringForm(self):
        """form setze generischen search string fuer MD"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','setGenericSearchStringForm.zpt')).__of__(self)
        return pt()

    def setGenericSearchString(self,searchString):
        """setze generischen search string"""
        self.searchString=searchString

    def thumblistMD(self):
        """main template collection"""
        logTime("thumbList MD %s"%self.REQUEST['QUERY_STRING'])
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbListMD.zpt')).__of__(self)
        self.REQUEST.RESPONSE.setHeader('Cache-Control','max-age=3600')
        self.REQUEST.RESPONSE.setHeader('Last-Modified',self.bobobase_modification_time().toZone('GMT').rfc822())
        return pt()
    
    
    def getRights(self,id):
        """get the rights from a database"""
        #print self.rightsQuery%id
        results=self.ZSQLSimpleSearch(self.getRightsQuery()%id)
        logging.error("rightsQuery: %s"%(self.getRightsQuery()%id))
        if results:
            result = getattr(results[0],self.getRightsQueryField())
        else:
            result = ''
        return result
     
    def xmlinput(self,url):
        """Anzeige von ausgewaehlten thumbs"""
        #return url
        
        url=urllib.unquote(url)
     
        url=url.replace(" ","+") # ersetze Leerzeichen in der URL durch "+"
        print url
        xmldoc=urllib.urlopen(url).read()
        #return xmldoc
        try:
                dom=NonvalidatingReader.parseUri(url)

        except:
                return "ERROR: (%s %s) %s"%(sys.exc_info()[0],sys.exc_info()[1],xmldoc)


        imagenames=dom.xpath("//imagename")
        rc=[]
        fnIds={}
        for imagename in imagenames:

                #imagename=image.xpath('./imagename')[0]
                #print "im",imagename
                
                
                
                idnr=imagename.xpath('../idnr')[0]
                id=getText(idnr.childNodes)
                try:
                    numberOfPages=imagename.xpath('../numberOfPages')[0]
                except:
                    numberOfPages=None
                    
                if numberOfPages:
                    nopT=getText(numberOfPages.childNodes)
                    try:
                            nop=int(nopT)
                    except:
                            nop=0
                else:
                    nop=0
                            
                texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
                for text in texts:
                    if not text=="":
                        #print "a"
                        text=self.getImageByName(text,onlyName="yes")
                        #print "b"
                        try:
                                rc.append((str(text),id,nop))
                                fnIds[str(text)]=(id,nop)
                        except:
                                rc.append((repr(text),id,nop))
                                fnIds[repr(text)]=(id,nop)
                
        #print "done"
        rc.sort()
        self.REQUEST.SESSION['filenames']=rc
        self.REQUEST.SESSION['filenamesIds']=fnIds
        
        overview=self.ZopeFind(self,obj_ids=['overview_selectedMD.html'])
            
        if overview:
                return overview[0][1]()
        else:
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
                return pt()        
        
        
    def selection(self):
        """show only selected"""
        if self.REQUEST.has_key('filename'):
            filen=self.REQUEST['filename']
        else:
            filen=""
        self.REQUEST.SESSION['filename']=filen
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selectedMD.zpt')).__of__(self)
        return pt()  
        
    def thumblistSelectedMD(self):
        """main template collection"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselectedMD.zpt')).__of__(self)
        return pt()
    
def manage_AddImageCollectionMDForm(self):
    """Nothing yet"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionFormMD.zpt')).__of__(self)
    return pt()
    
def manage_AddImageCollectionMD(self,id,title,ImageViewerPath,defaultMetaString,destBasis,srcBasis,serverPath,RESPONSE=None):
    """Add ImageCollection"""
    newObj=ImageCollectionMD(id,title,ImageViewerPath,defaultMetaString,destBasis,srcBasis,serverPath)
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')



        
class ImageCollectionIFrame(ImageCollection):
    """Class fuer Collection set als IFrame"""

    meta_type="ImageCollectionIFrame"
    label=ImageCollection.title

    def getImageTag(self):
        """ hack : method needed by echo_content"""
        return ""
    
    def rotate(self,angle,url,RESPONSE):
        """rotate"""
        
        RESPONSE.redirect("javascript:document.domain='mpg.de';parent.iframe.right.rotation(%i)"%int(angle))
        RESPONSE.redirect(url)
    def request(self):
        """request"""
        return self.REQUEST
        
    def index_html(self):
        """index"""
        if self.REQUEST.has_key('filename'):
            filen=self.REQUEST['filename']
        else:
            filen=""
        self.REQUEST.SESSION['filename']=filen
        
    
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameMain.zpt')).__of__(self)
        return pt()

    def iframe_html(self):
        """iframe"""
        if self.REQUEST.has_key('filename'):
            filen=self.REQUEST['filename']
        else:
            filen=""
        self.REQUEST.response.setCookie('filename',filen)
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameOverview.zpt')).__of__(self)
        return pt()


def manage_AddImageCollectionIFrameForm(self):
    """Nothing yet"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionIFrameForm.zpt')).__of__(self)
    return pt()
    
def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
    """Add ImageCollection"""
    newObj=ImageCollectionIFrame(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


class ImageZogiLib(ImageDigilib):
    """Anzeige Object fuer Bilder ausserhalb von collections
    ImageViewerPath und ImageStoragePath und wenn vorhanden Pfad zur Collection
    werden zusaetzlich abgespeichert
    """
    #TODO: scaler path notwendig?
    meta_type="ImageZogiLib"

    manage_options=ImageDigilib.manage_options+(
         {'label':'Main Config','action':'changeImageZogiLibForm'},        
        )

    def __init__(self,id,fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath=None,REQUEST=None):
        ImageDigilib.__init__(self,id,fn)
        self.ImageViewerPath=ImageViewerPath
        self.ImageStoragePath=ImageStoragePath
        self.ImageCollectionPath=ImageCollectionPath
        self.scalerPath=scalerPath

    def changeImageZogiLibForm(self):
        """change zogilib Form"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeImageZogiLib.zpt')).__of__(self)
        return pt()        


    def changeImageZogilib(fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath,REQUEST=None):
        """Change it"""
        self.ImageViewerPath=ImageViewerPath
        self.ImageStoragePath=ImageStoragePath
        self.ImageCollectionPath=ImageColectionPath
        self.scalerPath=scalerPath
    
def manage_AddImageZogiLib(self,id=None,ImageViewerPath=None,ImageStoragePath=None,fileUpload=None,ImageCollectionPath=None,scalerPath=None,libPath=None,caption=None,RESPONSE=None):
    """hinzufuegen eineis zogilibImage"""

    if libPath:
        splitted=libPath.split("?")
        urlSplit=splitted[0].split("/")
        params=cgi.parse_qs(splitted[1])
        #is LibPath a digilib path?
        if urlSplit[-1]=="Scaler":
            if type(params['fn']) is ListType:
                fnParam=params['fn'][0]
            else:
                fnParam=params['fn']
            fileNameSplit=os.path.split(fnParam)
            ImageViewerPath=fileNameSplit[0]
            id=fileNameSplit[1]
            scalerPath=splitted[0]+"?fn="
        else: #assume if not the path is a path to an ImageCollection
            if type(params['filename']) is ListType:
                id=params['filename'][0]
            else:
                id=params['filename']

            server=ServerProxy(splitted[0])
            ImageCollectionPath=libPath
            ImageViewerPath=server.getImageViewerPath()
            ImageStoragePath=server.getImageStoragePath()
            scalerPath=server.getScalerPath()
        


    if fileUpload:
        fn=splitPath(fileUpload.filename)
    else:
        fn=id
        
    newObj=ImageZogiLib(id,fn,ImageViewerPath,ImageStoragePath,scalerPath,ImageCollectionPath)
    
    self._setObject(id,newObj)
    getattr(self,id).caption=caption[0:]
    if fileUpload:
        getattr(self,id).uploadImage(fileupload,self.getImageStoragePath())
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

                 
def manage_AddImageZogiLibForm(self):
    """to be done"""