from OFS.Folder import Folder
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
import re
import os
import os.path
import urllib
import xml.dom.minidom
import operator
import tempfile
import shutil


try:
    from Products.ECHO_content.ECHO_collection import ECHO_basis
except:
    print "ECHO Elements not imported"
    ECHO_basis=None
	
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


class ImageDigilib(Folder,Persistent,Implicit):
    """Anzeige object fuer digilib"""
    meta_type="ImageDigilib"

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

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

    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 getMeta(self):
        """ausgabe der metadaten"""
        return self.meta
    
    def uploadImage(self,fileupload,path_name):
        """upload an Image from an Requast"""
        #path_name=self.ImageStoragePath
        fn=splitPath(fileupload.filename)
        filename=path_name+"/"+fn
        filedata=fileupload.read()
        f=open(filename,"w")
        f.write(filedata)
        f.close()
        try:
            os.chmod(filename,0644)
        except:
            """hack"""
	#scale 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"""
        path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt
	
	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")
	image=urllib.urlopen(path).read()
	self.REQUEST.RESPONSE.write(image)
	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()        

    def updateImage(self,file,RESPONSE):
	    """lade neues Version des Bildes"""
	    #teste ob Dokumenten ordner schon vorhanden
	    imagePath=os.path.join(self.ImageStoragePath,self.getId())
	    path=os.path.join(self.ImageStoragePath,"."+self.getId()+".dir")
	    print "path",path
	    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.getId()))):
		    versionNumber+=1

	    #kopieren der bestehenden Version in den Versions ordner.
	    imageNewPath=os.path.join(path,"V%i_%s"%(versionNumber,self.getId()))
	    os.rename(imagePath,imageNewPath)

	    #lesen des upload files und schreiben
	    filedata=file.read()
	    f=open(imagePath,"w")
	    f.write(filedata)
	    f.close()
	    try:
		    os.chmod(imagePath,0664)
	    except:
		    """hack"""
	    #scale thumb
	
	    self.scaleThumbs()
	    
	    #scale standard

	    self.scaleWorkingVersions()

	    if RESPONSE:
		    RESPONSE.redirect(self.absolute_url())
	
	    return "done"
	    
    def thumb(self):
        """show thumb"""
        thumbname=os.path.splitext(self.filename)[0]+".jpg"
        ## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):
##             image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:18080/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150&mo=lores").read()
##             f=open("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname,"w")
##             f.write(image)
##             f.close()
##             os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 150 &"% self.ImageViewerPath)
            
        #DEVEL:take nausikaa for server solution
        
        path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+"&dw=100&dh=100&mo=lores"
        #path="/mpiwg/online/"+self.ImageViewerPath+"/"+thumbname
        self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self)
        return pt()
    
    def index_html(self):
        """show image"""
        #DEVELOP: take first one for server
        
        path="http://content.mpiwg-berlin.mpg.de/zogilib_images?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)
    newObj=ImageDigilib(id,fn,meta)
    
    self._setObject(id,newObj)
    getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

                 
class ImageCollection(Folder, Persistent, Implicit, ECHO_basis):
    """Sammelordner für Bilder"""
    meta_type="ImageCollection"

    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

   
    
    def createSet(self,RESPONSE=None,local=None,version="working"):
	    """download aller gewaehlten files"""
	    tempfile.tempdir="/tmp/archivesImageServer"
	    
	    tmpPath=tempfile.mktemp()
	    

	    tmpZip=tempfile.mktemp()+".zip"
	    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) 
	    
	    
	    if RESPONSE:
		    RESPONSE.setHeader("Content-Type","text/html")
		    RESPONSE.write("<h1>I am creating  the download archive</h1>")
		    RESPONSE.write("<h3>1. step: getting the images</h3>")

	    if not self.REQUEST.SESSION.has_key('filenames'):
		    RESPONSE.write("<h2>ERROR</h2>")
		    RESPONSE.write("<p>I forgot, the selected files. Please reselect.\n")
		    return 0
	    
	    for id in self.REQUEST.SESSION['filenames']:

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

		    if RESPONSE:
			    RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))

		    if local:
			    if version=="working":
				    sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"
			    else:
				    sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]
			    targetPath=tmpPath+"/"+filename
			    try:
				    shutil.copyfile(sourcePath,targetPath)
			    except:
				    if RESPONSE:
					    RESPONSE.write(str("<p>Error in File: %s (possible missing)<br>\n"%filename))
				    else:
					    """nothing"""
		    else:
			    if version=="working":
				    path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&dh=2000&dw=2000"
			    else:
				    path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
			    image=urllib.urlopen(path).read()
		    
		    
			    fh=file(tmpPath+"/"+filename,"w")

		    
			    fh.write(image)
			    fh.close()

		    #folgeseiten
		    if int(self.REQUEST.SESSION['filenamesIds'][id[0]][1])>1: 
			    ids=self.show_thumbs()
			    nr=ids.index(id[0])
			    
			    numberOfPages=self.REQUEST.SESSION['filenamesIds'][id[0]][1]
			    for k in range(int(numberOfPages)-1):
				    i=k+1
				    if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(id[0]):
					    filename=self.REQUEST.SESSION['filenamesIds'][id[0]][0]+"_"+ids[nr+i]
				    else:
					    filename=id[0]

				    if RESPONSE:
					    RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))

				    if local:
					    sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+ids[nr+1]
					    targetPath=tmpPath+"/"+filename
					    try:
						    shutil.copyfile(sourcePath,targetPath)
					    except:
						    if RESPONSE:
							    RESPONSE.write(str("<p>Error in File: %s (missing?)<br>\n"%filename))
						    else:
							    """nothing"""
				    else:
					    path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"

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

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

	    if RESPONSE:
		    RESPONSE.write("<h3>2. step: creating the downloadable file</h3>")
		    RESPONSE.write("<p>Create Zip<br>")
		    RESPONSE.write("<p>This can take a while....<br>\n")
	    if RESPONSE:
		    fh=os.popen2("zip -u %s %s/*"%(tmpZip,tmpPath),1)[1]
		    RESPONSE.write("<br>")
		    for c in fh.read():
			    RESPONSE.write(c)

			    if c==")":
				    RESPONSE.write("<br>\n")
		    
			    
	    else:
		    os.popen("zip -u %s %s/*"%(tmpZip,tmpPath))

	    
	    shutil.rmtree(tmpPath)

	    if RESPONSE:
		    RESPONSE.write("<p>finished<br>\n")

	    if RESPONSE:
		    len=os.stat(tmpZip)[6]
		    downloadUrl=self.absolute_url()+"/downloadSet"
		    RESPONSE.write("""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
		    RESPONSE.write("""<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))
		    RESPONSE.close()
	    
    def downloadSet(self,fn):
	    """download prepared set"""
	    filename="/tmp/archivesImageServer/"+fn
	    
	    self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.zip")
	    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 scaleThumbs(self,RESPONSE=None):
        """scale thumbs"""
	
	#scale thumbs
        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

	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,ImageStoragePath,ImageViewerPath,defaultMetaString):
        self.id=id
        self.title=title
        self.ImageStoragePath=ImageStoragePath
        self.ImageViewerPath=ImageViewerPath
        self.defaultMetaString=defaultMetaString

    if ECHO_basis:
        optTMP= Folder.manage_options+ECHO_basis.manage_options
    else:
        optTMP= Folder.manage_options

    manage_options = optTMP+(
        {'label':'Main Config','action':'ImageCollection_config'},
        {'label':'Import','action':'ImportFiles'},
        {'label':'Recalculate Metadata','action':'recalculateMeta'},
        {'label':'Import Metadata','action':'importMetaForm'},
        {'label':'Rescale thumbs','action':'scaleThumbs'},
	{'label':'Rescale working version','action':'scaleWorkingVersions'},
        )

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

    def importMeta(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 % 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 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)
		numberOfPages=image.getElementsByTagName('numberOfPages')[0]
		nopT=getText(numberOfPages.childNodes)
		try:
			nop=int(nopT)
		except:
			nop=0
                texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
                for text in texts:
                    if not text=="":
			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
	
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
        return pt()        

    def recalculateMeta(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,meta,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=splitPath(fileupload.filename)

        manage_AddImageDigilib(self,fn,fileupload,meta=meta)
        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.ImageStoragePath)
        ret=""
        #print self.__dict__
        for file in files:
            if not file[0]==".":
                if self.__dict__.has_key(file):

                    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.ImageStoragePath

 	#scale thumb
	
        self.scaleThumbs()

	#scale standard

	self.scaleWorkingVersions()
	

        RESPONSE.redirect('manage_main')
    
    def ImportFiles(self,RESPONSE=None):
        """Import the existing files of a folder"""
        files=os.listdir(self.ImageStoragePath)
        ret=""
        #print self.__dict__
        for file in files:
            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.ImageStoragePath

		#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,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
        """Change"""
        self.title=title
        self.ImageStoragePath=ImageStoragePath
        self.ImageViewerPath=ImageViewerPath
        self.defaultMetaString=defaultMetaString
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def show_selected_thumbs(self):
        #ids=[]
        
        return self.REQUEST.SESSION['filenames']

    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):
        ids=self.show_thumbs()
        if ids:
            if selected:
                return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
            else:
                return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">first sets</a>"

    def lastSets(self,selected=None):
        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\">last set</a>"
            else:
                return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">last sets</a>"

        
                
    def nextSets(self,selected=None):
        """show nextimage"""
        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>=len(ids):
                            nr=len(ids)-1
                    except:
                        nr=0
                else:
                    nr=0

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

    def prevSets(self,selected=None):
        
        """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\">previous sets</a>"
                    else:
                        return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
            else:
                return ""

    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':
            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="<b>Show thumbnail group no:</b></br>"
                for i in range(num):
                    if (operator.mod(i,10)==0) and i>0:
                        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):
        """Ausgabe anzahl"""
        ids=self.show_selected_thumbs()
        self.REQUEST.SESSION['ids']=ids
        number=int(len(ids)/numberOfColumns)+1
        self.REQUEST.SESSION['number']=range(number)
        return range(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 getColTimesRow(self,showall='No'):
        """coltimesrow"""
        
        REQUEST=self.REQUEST
        """matrix"""
        if REQUEST.cookies.has_key("ImageViewerRows"):
            
            try:
                rows=int(REQUEST.cookies["ImageViewerRows"])
            except:
                rows=6
        else:
            rows=6
            
        if REQUEST.cookies.has_key("ImageViewerCols"):
            #print "COLS",REQUEST.cookies["ImageViewerCols"]
            cols=int(REQUEST.cookies["ImageViewerCols"])
        else:
            cols=2

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

        #print cols,rows
        if showall=='yes':
            rows=int(idsnumber/cols)+1
            
        return (cols,rows)
                
        
    def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None):
        """Ausgabe anzahl"""

        idsAll=self.show_thumbs()
        if len(idsAll)==0: #keine Einträge
            return 0
        if self.REQUEST.SESSION.has_key("filename"):
            filename=self.REQUEST.SESSION["filename"]
            
                
            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
    
        return range(number+1)

    def show_thumbs_columns(self,row,numberOfColumns):
        """Ausgabe einer Liste der Reihe"""
        ids=self.REQUEST.SESSION['ids']
        max=len(ids)
        if (row*numberOfColumns)<max:
            return ids[(row-1)*numberOfColumns:row*numberOfColumns]
        else:
            return ids[(row-1)*numberOfColumns:]
        
    def thumblistSelected_old(self):
        """main template collection"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected.zpt')).__of__(self)
        return pt()

    def thumblistSelected(self):
        """main template collection"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected2.zpt')).__of__(self)
        return pt()
    
    def thumblist_old(self):
        """main template collection"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.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()

    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 index_html(self):
        """main template collection"""
        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')
            
     
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__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,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
    """Add ImageCollection"""
    newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
    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')