File:  [Repository] / ImageArchive / ImageArchive.py
Revision 1.56: download - view: text, annotated - select for diffs - revision graph
Fri Apr 29 15:14:31 2005 UTC (19 years, 1 month ago) by dwinter
Branches: MAIN
CVS tags: HEAD
minorCVS: ----------------------------------------------------------------------

    1: from OFS.Folder import Folder
    2: from OFS.SimpleItem import SimpleItem
    3: from Globals import Persistent,package_home
    4: from Acquisition import Implicit
    5: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    6: from Products.PageTemplates.PageTemplate import PageTemplate
    7: import re
    8: import os
    9: import os.path
   10: import urllib
   11: import xml.dom.minidom
   12: import operator
   13: import tempfile
   14: import shutil
   15: from types import *
   16: import time
   17: from threading import Thread
   18: import Queue
   19: 
   20: try:
   21:     from Products.ECHO_content.ECHO_collection import ECHO_basis
   22: except:
   23:     print "ECHO Elements not imported"
   24:     class ECHO_basis:
   25:         """leer"""
   26: 
   27:         manage_options=()
   28: 
   29: 
   30: tdir = "/mpiwg/temp/tmp/archivesImageServer/"
   31: #tdir="/tmp/archivesImageServer/"
   32: 
   33: def splitPath(str):
   34: 	str2=str.replace("\\","/")
   35: 	return os.path.split(str2)[1]
   36: 
   37: def getText(nodelist):
   38:     
   39:     rc = ""
   40:     for node in nodelist:
   41:     
   42:     	if node.nodeType == node.TEXT_NODE:
   43:            rc = rc + node.data
   44:     return rc
   45: 
   46: def getTextFromNode(nodename):
   47:     nodelist=nodename.childNodes
   48:     rc = ""
   49:     for node in nodelist:
   50:     	if node.nodeType == node.TEXT_NODE:
   51:            rc = rc + node.data
   52:     return rc
   53: 
   54: class generateSet:
   55:     """generateSetThread"""
   56: 
   57:         
   58:     def __init__(self,filenames,filenamesIds,ImageViewerPath,ids,url,local=None,version="working"):
   59:         """init generateSet"""
   60:         self.filenames=filenames
   61:         self.filenamesIds=filenamesIds
   62:         self.ImageViewerPath=ImageViewerPath
   63:         self.ids=ids
   64:         self.local=local
   65:         self.url=url
   66:         self.version=version
   67:         self.done=None
   68: 
   69: 
   70:     def __call__(self):
   71:         """call generate Set"""
   72: 
   73:         storeTempDir=tempfile.tempdir
   74: 	tempfile.tempdir=tdir
   75: 
   76:         tmpPath=tempfile.mktemp()
   77:         tmpZip=tempfile.mktemp()+".gtz"
   78:         tmpFn=os.path.split(tmpZip)[1]
   79: 
   80:         if not os.path.exists(tempfile.tempdir):
   81:             os.mkdir(tempfile.tempdir) 
   82: 
   83:         if not os.path.exists(tmpPath):
   84: 		    os.mkdir(tmpPath) 
   85: 	    
   86: 	self.response=""
   87: 
   88:         
   89:         self.response="<h3>1. step: getting the images</h3>"
   90: 
   91:         for id in self.filenames:
   92: 
   93: 		    if self.filenamesIds.has_key(id[0]):
   94: 			    filename=self.filenamesIds[id[0]][0]+"_"+id[0]
   95: 		    else:
   96: 			    filename=id[0]
   97: 
   98:                     self.response+=str("<p>Get File: %s<br>\n"%filename)
   99: 
  100: 		    if self.local:
  101: 			    
  102: 			    if self.version=="working":
  103: 
  104: 				    sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"
  105: 			    else:
  106: 				    sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]
  107: 			    targetPath=tmpPath+"/"+filename
  108: 			    try:
  109:                                 shutil.copyfile(sourcePath,targetPath)
  110: 			    except:
  111:                                 self.response+=(str("<p>Error in File: %s (possible missing)<br>\n"%filename))
  112: 		    else:
  113: 			    if self.version=="working":
  114: 				    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"
  115: 			    else:
  116: 				    path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
  117: 			    image=urllib.urlopen(path).read()
  118: 		    
  119: 		    
  120: 			    fh=file(tmpPath+"/"+filename,"w")
  121: 
  122: 		    
  123: 			    fh.write(image)
  124: 			    fh.close()
  125: 
  126:                     #folgeseiten
  127: 		    if int(self.filenamesIds[id[0]][1])>1: 
  128: 			    #ids=self.show_thumbs()
  129:                             
  130: 		            try:
  131:                                 nr=self.ids.index(id[0])
  132: 			    except:
  133:                                 self.response+=str("<p>Error in File: %s (possible missing)<br>\n"%id[0])
  134:                 
  135: 
  136:                                 nr=0
  137: 
  138: 			    numberOfPages=self.filenamesIds[id[0]][1]
  139: 			    for k in range(int(numberOfPages)-1):
  140: 				    i=k+1
  141: 				    if self.filenamesIds.has_key(id[0]):
  142: 					    filename=self.filenamesIds[id[0]][0]+"_"+self.ids[nr+i]
  143: 				    else:
  144: 					    filename=id[0]
  145: 
  146:                                     self.response+=str("<p>Get File: %s<br>\n"%filename)
  147: 
  148: 				    if self.local:
  149: 					    sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+self.ids[nr+1]
  150: 					    targetPath=tmpPath+"/"+filename
  151: 					    try:
  152: 						    shutil.copyfile(sourcePath,targetPath)
  153: 					    except:
  154:                                                 self.response+=str("<p>Error in File: %s (missing?)<br>\n"%filename)
  155: 						  
  156: 				    else:
  157: 					    path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"
  158: 
  159: 					    image=urllib.urlopen(path).read()
  160: 				    
  161: 
  162: 					    fh=file(tmpPath+"/"+filename,"w")
  163: 					    fh.write(image)
  164: 					    fh.close()
  165: 
  166:         self.response+="<h3>2. step: creating the downloadable file</h3>"
  167: 	self.response+="<p>Create gtar<br>"
  168:         self.response+="<p>This can take a while....<br>\n"
  169: 
  170:         fh=os.popen2("gnutar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
  171:         self.response+="<br>"
  172:         for c in fh.read():
  173:             self.response+=c
  174:             if c==")":
  175:                 self.response+="<br>\n"
  176: 		    
  177: 			    
  178: 
  179:         
  180:         shutil.rmtree(tmpPath)
  181: 
  182:         self.response+="<p>finished<br>\n"
  183: 
  184:         len=os.stat(tmpZip)[6]
  185:         downloadUrl=self.url+"/downloadSet"
  186:         self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
  187:         self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
  188: 		    <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
  189: 
  190:         self.done=True
  191:     def getResult(self):
  192:         """get result"""
  193:         return self.response
  194: 
  195:     def isDone(self):
  196:         if self.done:
  197:             return True
  198:         else:
  199:             return False
  200:         
  201: class metaData(SimpleItem):
  202:     """Klasse fuer metadaten"""
  203:     meta_type="metaData"
  204:     
  205:     def __init__(self,xmlurl,container=None):
  206:         """__init__"""
  207:         return self.update(xmlurl,container)
  208: 
  209: 
  210:     def update(self,xmlurl,container=None):
  211:         """update"""
  212: 
  213:         try:
  214:             xmlfh=urllib.urlopen(xmlurl)
  215:             dom=xml.dom.minidom.parse(xmlfh)
  216:         except:
  217:             return None
  218: 
  219:         md=dom.getElementsByTagName(container)
  220:         mlist=[]
  221:         if md:
  222:             for node in md[0].childNodes:
  223:                 if node.nodeType==dom.ELEMENT_NODE:
  224:                     name=node.tagName
  225:                     content=getTextFromNode(node)
  226:                     setattr(self,name,content)
  227:                     mlist.append(name)
  228:             self.mlist=mlist[0:]
  229:         else:
  230:             self.mlist=[]
  231:         
  232:     def index_html(self):
  233:         """index"""
  234:         ret="<html><body>"
  235:         for tag in self.mlist:
  236:             ret+="<p>%s=%s</p>"%(tag,getattr(self,tag))
  237:         return ret+"</body></html>"
  238:                 
  239:         
  240: class ImageDigilib(Folder,Persistent,Implicit):
  241:     """Anzeige object fuer digilib"""
  242:     meta_type="ImageDigilib"
  243: 
  244:     leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
  245: 
  246:     manage_options = Folder.manage_options+(
  247:         
  248:         {'label':'Add Metadata','action':'addMetaObjectForm'},
  249:         
  250:         )
  251: 
  252:     def addMetaObject(self,id,RESPONSE=None):
  253:         """Add an MetaObject"""
  254:         objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
  255: 
  256:         request=self.REQUEST
  257:         objectCreate=objectType.createObjectManager(id,request)
  258: 
  259:         self._setObject(id,objectCreate)
  260:         
  261:         objectCreate.propertysheets.meta.manage_editProperties(request)
  262: 
  263:         if RESPONSE is not None:
  264:             RESPONSE.redirect('manage_main')
  265: 
  266:         
  267: 
  268: 
  269:     def addMetaObjectForm(self):
  270:         """Add Form"""
  271:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetaObject.zpt')).__of__(self)
  272:         return pt()        
  273: 
  274: 
  275:     def __init__(self,id,filename,meta=None):
  276:         self.id=id
  277:         self.title=filename
  278:         self.filename=filename
  279:         self.meta=meta
  280: 
  281:     def getMeta(self):
  282:         """ausgabe der metadaten"""
  283:         return self.meta
  284: 
  285:     def manageMetaData(self,strict=None):
  286:         """create or updateMetadata"""
  287:         
  288:         md=self.ZopeFind(self,obj_metatypes=["metaData"])
  289:         
  290:         if not md:
  291:             self._setObject("metaData",metaData(self.meta,"ROW"))
  292: 
  293:         else:
  294:             if not strict:
  295:                 md[0][1].update(self.meta,"ROW")
  296:             else:
  297:                 print "strict"
  298:                 if len(md[0][1].mlist)==0:
  299:                     print " +++",self.getId()
  300:                     md[0][1].update(self.meta,"ROW")
  301:                 else:
  302:                     print " ---",self.getId()
  303:                     
  304:     def uploadImage(self,fileupload,path_name):
  305:         """upload an Image from an Requast"""
  306:         #path_name=self.ImageStoragePath
  307:         fn=splitPath(fileupload.filename)
  308:         filename=path_name+"/"+fn
  309:         filedata=fileupload.read()
  310:         f=open(filename,"w")
  311:         f.write(filedata)
  312:         f.close()
  313:         try:
  314:             os.chmod(filename,0664)
  315:         except:
  316:             """hack"""
  317: 	#scale thumb
  318: 	
  319:         self.scaleThumbs()
  320: 
  321: 	#scale standard
  322: 
  323: 	self.scaleWorkingVersions()
  324: 
  325: 	
  326: 	
  327:     def downloadWorkingVersion(self):
  328: 	    """download working version (2000 pixel)"""
  329: 	    
  330: 	    return self.download(fmt="&dw=2000&dh=2000",suffix=".jpg")
  331:     
  332:     def download(self,fmt="&mo=rawfile,hires",suffix=None):
  333:         """download"""
  334:         path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt
  335: 	
  336: 	if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(self.filename):
  337: 		filename=self.REQUEST.SESSION['filenamesIds'][self.filename][0]+"_"+self.filename
  338: 	else:
  339: 		filename=self.filename
  340: 
  341: 	if suffix:
  342: 		filename=os.path.splitext(filename)[0]+suffix
  343: 		
  344: 	self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)
  345: 	self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
  346:         #print path
  347: 	imagefh=urllib.urlopen(path,'rb')
  348:         
  349: 	self.REQUEST.RESPONSE.write(imagefh.read())
  350: 	self.REQUEST.RESPONSE.close()
  351:         #return self.REQUEST.RESPONSE.redirect(path)
  352: 
  353:     def updateImageForm(self):
  354: 	    """form"""
  355: 	    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateImageForm.zpt')).__of__(self)
  356: 	    return pt()        
  357: 
  358:     def renameImageForm(self):
  359: 	    """form"""
  360: 	    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','renameImageForm.zpt')).__of__(self)
  361: 	    return pt()
  362: 
  363:     def renameImage(self,newname,RESPONSE=None):
  364: 	    """umbenennen"""
  365: 	    #umbennen des files im folder
  366: 	    oldname=self.getId()
  367: 	    self.aq_parent.manage_renameObjects(ids=[oldname],new_ids=[newname])
  368: 	    self.title=newname[0:]
  369:             self.filename=newname[0:]	
  370:             #umbennen des files auf dem server
  371: 	    oldpath=os.path.join(self.ImageStoragePath,oldname)
  372: 	    newpath=os.path.join(self.ImageStoragePath,newname)
  373:             os.rename(oldpath,newpath)
  374: 	    
  375: 	    #umbenennen des versionsfolders
  376: 	    oldfolder=os.path.join(self.ImageStoragePath,"."+oldname+".dir")
  377:             newfolder=os.path.join(self.ImageStoragePath,"."+newname+".dir")
  378: 	    if os.path.exists(oldfolder):
  379:                 os.rename(oldfolder,newfolder)
  380:             else:
  381:                 os.mkdir(newfolder)
  382:                 
  383: 	    #schreibe info uber umbennenung
  384: 
  385:             renameName=os.path.join(newfolder,"renamed")
  386:             if os.path.exists(renameName):
  387:                 fh=file(renameName,'a')
  388:             else:
  389:                 fh=file(renameName,'w')
  390: 
  391:             tm=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
  392:             try:
  393:                 user=self.REQUEST['AUTHENTICATED_USER']
  394:             except:
  395:                 user="unknown"
  396: 
  397:             str="""%s %s %s %s\n"""%(tm,user,oldname,newname)
  398:             fh.write(str)
  399:             fh.close()
  400:             
  401:             #scale thumb
  402: 	
  403: 	    self.scaleThumbs()
  404: 	    
  405: 	    #scale standard
  406: 
  407: 	    self.scaleWorkingVersions()
  408: 
  409: 
  410:             if RESPONSE:
  411: 		    RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)
  412: 	
  413: 
  414:     def updateImage(self,file,rename=None,RESPONSE=None):
  415: 	    """lade neues Version des Bildes"""
  416: 	    #teste ob Dokumenten ordner schon vorhanden
  417: 	    imagePath=os.path.join(self.ImageStoragePath,self.getId())
  418: 	    path=os.path.join(self.ImageStoragePath,"."+self.getId()+".dir")
  419: 	    
  420: 	    if not os.path.exists(path):
  421: 		    os.mkdir(path,0775)
  422: 		    os.chmod(path,0775)
  423: 		    
  424: 	    versionNumber=getattr(self,'versionNumber',0)+1
  425: 
  426: 	    #teste ob version schon existiert
  427: 
  428: 	    while os.path.exists(os.path.join(path,"V%i_%s"%(versionNumber,self.getId()))):
  429: 		    versionNumber+=1
  430: 
  431: 	    #kopieren der bestehenden Version in den Versions ordner.
  432: 	    imageNewPath=os.path.join(path,"V%i_%s"%(versionNumber,self.getId()))
  433: 	    os.rename(imagePath,imageNewPath)
  434: 
  435: 	    #lesen des upload files und schreiben
  436: 	    filedata=file.read()
  437: 	    f=open(imagePath,"w")
  438: 	    f.write(filedata)
  439: 	    f.close()
  440: 	    try:
  441: 		    os.chmod(imagePath,0664)
  442: 	    except:
  443: 		    """hack"""
  444: 	    #scale thumb
  445: 	
  446: 	    self.scaleThumbs()
  447: 	    
  448: 	    #scale standard
  449: 
  450: 	    self.scaleWorkingVersions()
  451: 
  452: 	    if rename:
  453: 		self.renameImage(file.filename)
  454: 	
  455: 	
  456: 	    if RESPONSE:
  457: 		    RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)
  458: 	
  459: 
  460: 	    return "done"
  461: 	    
  462:     def thumb(self,url=None):
  463:         """show thumb"""
  464:         thumbname=os.path.splitext(self.filename)[0]+".jpg"
  465:         ## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):
  466: ##             image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:18080/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150&mo=lores").read()
  467: ##             f=open("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname,"w")
  468: ##             f.write(image)
  469: ##             f.close()
  470: ##             os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 150 &"% self.ImageViewerPath)
  471:             
  472:         #DEVEL:take nausikaa for server solution
  473:         
  474:         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"
  475:         #path="/mpiwg/online/"+self.ImageViewerPath+"/"+thumbname
  476:         self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
  477:         if url:
  478:             return "<img border=\"0\" src=\"%s\">"% path
  479:         else:
  480:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self)
  481:             return pt()
  482:     
  483:     def index_html(self):
  484:         """show image"""
  485:         #DEVELOP: take first one for server
  486:         
  487:         path="http://content.mpiwg-berlin.mpg.de/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]
  488:         return self.REQUEST.RESPONSE.redirect(path)
  489: 
  490:     
  491: def manage_AddImageDigilibForm(self):
  492:     """Nothing yet"""
  493:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageDigilibForm.zpt')).__of__(self)
  494:     return pt()
  495:     
  496: def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
  497:     """Add ImageCollection"""
  498:     
  499:     #fileupload=self.REQUEST['fileupload']
  500:     fn=splitPath(fileupload.filename)
  501:     newObj=ImageDigilib(id,fn,meta)
  502:     
  503:     self._setObject(id,newObj)
  504:     getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
  505:     
  506:     if RESPONSE is not None:
  507:         RESPONSE.redirect('manage_main')
  508: 
  509:                  
  510: 
  511: class ImageCollection(Folder, Persistent, Implicit,ECHO_basis):
  512: 
  513:     """Sammelordner für Bilder"""
  514:     meta_type="ImageCollection"
  515: 
  516:    
  517:     zipThreads={}
  518:     zipThreads2={}
  519:     
  520:     genericMetaDataType="leiden_meta"
  521: 
  522:     leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
  523: 
  524:     
  525:     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
  526: 
  527:    
  528:     def refreshTxt(self):
  529:         """txt fuer refresh"""
  530:         tn=self.REQUEST.SESSION['threadName']
  531:         return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/createSet",tn)
  532: 
  533:     def createSet(self,RESPONSE=None,local=None,version="working",repeat=None):
  534: 	    """download aller gewaehlten files"""
  535: 
  536:             threadName=repeat
  537:         
  538:                        
  539:             if not threadName or threadName=="":
  540:                 threadStart=generateSet(self.REQUEST.SESSION['filenames'],self.REQUEST.SESSION['filenamesIds'],self.ImageViewerPath,self.show_thumbs(),self.absolute_url(),local=local,version=version)
  541:                 thread=Thread(target=threadStart)
  542:                 
  543:                 thread.start()
  544: 
  545:                     
  546:                 self.zipThreads[thread.getName()[0:]]=threadStart
  547:                 self.zipThreads2[thread.getName()[0:]]=thread
  548:                 self.REQUEST.SESSION['threadName']=thread.getName()[0:]
  549:                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
  550:                 if wait_template:
  551:                     return wait_template[0][1]()
  552:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
  553:                 return pt()
  554:                 #xmltrans.run()
  555:             else:
  556:                 self.REQUEST.SESSION['threadName']=threadName
  557: 
  558:                 if (self.zipThreads[threadName].getResult()==None):
  559: 
  560:                     wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
  561:                     if wait_template:
  562:                 	return wait_template[0][1]()
  563:                 
  564:                     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
  565:                     return pt()
  566:                 else:
  567:                     if self.zipThreads[threadName].isDone():
  568:                         self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
  569:                         self.zipThreads2[threadName].join()
  570:                         del(self.zipThreads2[threadName])
  571:                         del(self.zipThreads[threadName])
  572:                         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
  573:                         return pt()
  574:                         
  575:                     else:
  576:                         self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
  577:                         self.REQUEST.SESSION['threadName']=threadName
  578:                         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
  579:                         return pt()
  580: 
  581: 
  582: 
  583: 
  584: 
  585:     def checkThreads(self):
  586:         """teste running threads"""
  587:         ret="""<html>
  588:         <head>
  589:         <meta http-equiv="REFRESH" content="5;url=%s/checkThreads"
  590:         <body><h2>Threads of %s</h2>"""%(self.absolute_url(),self.getId())
  591:         
  592:         for threadName in self.zipThreads.keys():
  593:             if self.zipThreads2[threadName].isAlive():
  594:                 ret+="<p>%s --> alive</p>"%threadName
  595:             else:
  596:                 ret+="<p>%s --> dead</p>"%threadName
  597:         return ret+"</body></html>"
  598:     
  599:     def downloadSet(self,fn):
  600: 	    """download prepared set"""
  601: 	    filename=os.path.join(tdir,fn)
  602: 
  603: 	    
  604: 	    self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.tgz")
  605: 	    self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
  606: 	    len=os.stat(filename)[6]
  607: 	    self.REQUEST.RESPONSE.setHeader("Content-Length",len)
  608: 	    images=file(filename).read()
  609: 	    self.REQUEST.RESPONSE.write(images)
  610: 	    self.REQUEST.RESPONSE.close()
  611: 
  612: 		    
  613: 		    
  614:     def scaleThumbs(self,RESPONSE=None):
  615:         """scale thumbs"""
  616: 	
  617: 	#scale thumbs
  618:         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)
  619: 	if RESPONSE:
  620: 		RESPONSE.write(ret.read())
  621: 		RESPONSE.write("\n")
  622: 		
  623:         return "RESCALING STARTED"
  624: 
  625:     def scaleWorkingVersions(self,RESPONSE=None):
  626:         """scale working versions"""
  627: 	
  628: 	#scale standard
  629: 
  630: 	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)
  631: 	if RESPONSE:
  632: 		RESPONSE.write(ret.read())
  633: 		RESPONSE.write("\n")
  634: 	return "rescaling started"
  635: 
  636: 
  637:     
  638:     def __init__(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString):
  639:         self.id=id
  640:         self.title=title
  641:         self.ImageStoragePath=ImageStoragePath
  642:         self.ImageViewerPath=ImageViewerPath
  643:         self.defaultMetaString=defaultMetaString
  644: 
  645:     optTMP= Folder.manage_options
  646: 
  647:     manage_options = optTMP+(
  648:         {'label':'Main Config','action':'ImageCollection_config'},
  649:         {'label':'Import','action':'ImportFiles'},
  650:         {'label':'Recalculate MetadataLink','action':'recalculateMetaLink'},
  651:         {'label':'Import Metadata File','action':'importMetaFileForm'},
  652:         {'label':'Import Metadata','action':'importMetaData'},
  653:         {'label':'Rescale thumbs','action':'scaleThumbs'},
  654: 	{'label':'Rescale working version','action':'scaleWorkingVersions'},
  655:         )
  656: 
  657:     
  658: 
  659:     def importMetaData(self,strict=None):
  660:         """import metadata, if strict ist not None then only metadata will be rebuild where metadata is empty"""
  661:         
  662:         for image in self.ZopeFind(self,obj_metatypes=["ImageDigilib"]):
  663:             print image[1].getId()
  664:             image[1].manageMetaData(strict)
  665:         return "ok"
  666:         
  667: 
  668:     def importMetaFileForm(self):
  669:         """import metadata"""
  670:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importMeta.zpt')).__of__(self)
  671:         return pt()
  672: 
  673:     def importMetaFile(self,fileupload,tag):
  674:         """import"""
  675:         filedata=fileupload.read()
  676:         dom=xml.dom.minidom.parseString(filedata)
  677:         rows=dom.getElementsByTagName(tag)
  678:         #print "ROWS",rows
  679:         request=self.REQUEST
  680:         for row in rows:
  681:             
  682:             for a in self.leiden_meta_fields:
  683:                 self.REQUEST[a]=getText(row.getElementsByTagName(a)[0].childNodes)
  684: 
  685:             image_id=self.REQUEST['image_id']
  686:             if (not hasattr(self,image_id)) & (not image_id==""):
  687:                 #print image_id
  688:                 newObj=ImageCollection(str(image_id),image_id,'','','')
  689:                 self._setObject(str(image_id),newObj)
  690: 
  691:             id="leiden_meta_data_file"
  692:             self.REQUEST['id']=id
  693:             #objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
  694:             #objectCreate=objectType.createInObjectManager(id,request)
  695:             #href="http://localhost:8080/tests/testcollection/manage_addProduct/ImageMetaData/leiden_meta_factory/"
  696:             try:
  697:                 addID=getattr(self,image_id)
  698:                 objectCreate=addID.manage_addProduct['ImageMetaData'].leiden_meta_add(id)
  699:                 #getattr(self,image_id)._setObject(id,objectCreate)
  700:                 obj=getattr(addID,id)
  701:                 obj.propertysheets.meta.manage_editProperties(request)
  702:             except:
  703:                 """nothing"""
  704:         return "OK"
  705:     
  706: 
  707:     def nextImage(self,request,selected=None,returnFn=None):
  708:         """show nextimage"""
  709:         try:
  710:             ids=self.show_thumbs()
  711:             if request.SESSION.has_key("filename"):
  712:                 filename=request.SESSION["filename"]
  713:                 try:
  714:                     nr=ids.index(filename)
  715: 		  
  716:                 except:
  717:                     nr=0
  718:             else:
  719:                 nr=0
  720: 
  721:             if nr==len(ids)-1:
  722: 		    return ""
  723:             else:
  724: 	        if returnFn:
  725: 			    return ids[nr+1]
  726: 		    
  727:                 if selected:
  728:                     return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
  729:                 else:
  730:                     return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
  731:         except:
  732:             return ""
  733:         
  734:     def prevImage(self,request,selected=None):
  735:         """show nextimage"""
  736:         #return self.getId()
  737:         try:
  738:             ids=self.show_thumbs()
  739:             if request.SESSION.has_key("filename"):
  740:                 filename=request.SESSION["filename"]
  741:                 try:
  742:                     nr=ids.index(filename)
  743:                 except:
  744:                     nr=0
  745:             else:
  746:                 nr=0
  747: 
  748:             if nr==0:
  749:                 return ""
  750:             else:
  751:                 if selected:
  752:                     return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
  753:                 else:
  754:                     return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
  755:         except:
  756:             return ""
  757:         
  758:     def meta_default(self,filename):
  759:         """url der metadaten"""
  760:         return self.defaultMetaString % urllib.quote(filename)
  761:                      
  762:     def getThumbAttribute(self,id,attr):
  763:         if hasattr(self,id):
  764:             return getattr(getattr(self,id),attr)
  765:         else:
  766:             if attr=='title':
  767:                 return "<b>Missing Image:%s</b>" % id
  768: 
  769:     def getThumbFunction(self,id,attr):
  770:         #return "DUMP"
  771:         if hasattr(self,id):
  772:             return getattr(getattr(self,id),attr)()
  773:         
  774:             
  775:     def xmlinput(self,url):
  776:         """Anzeige von ausgewaehlten thumbs"""
  777:         #return url
  778:         
  779:         url=urllib.unquote(url)
  780:         xmldoc=urllib.urlopen(url).read()
  781:         #return xmldoc
  782: 	try:
  783: 		dom=xml.dom.minidom.parseString(xmldoc)
  784:         except:
  785: 		return xmldoc
  786: 	images=dom.getElementsByTagName('image')
  787: 
  788:         rc=[]
  789: 	fnIds={}
  790:         for image in images:
  791: 		imagename=image.getElementsByTagName('imagename')[0]
  792:                 
  793: 		
  794:                 
  795: 		idnr=image.getElementsByTagName('idnr')[0]
  796: 		id=getText(idnr.childNodes)
  797: 		numberOfPages=image.getElementsByTagName('numberOfPages')[0]
  798: 		nopT=getText(numberOfPages.childNodes)
  799: 		try:
  800: 			nop=int(nopT)
  801: 		except:
  802: 			nop=0
  803:                 texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
  804:                 for text in texts:
  805:                     if not text=="":
  806: 			try:
  807: 				rc.append((str(text),id,nop))
  808: 				fnIds[str(text)]=(id,nop)
  809: 			except:
  810: 				rc.append((repr(text),id,nop))
  811: 				fnIds[repr(text)]=(id,nop)
  812:                 
  813: 
  814:         rc.sort()
  815:         self.REQUEST.SESSION['filenames']=rc
  816: 	self.REQUEST.SESSION['filenamesIds']=fnIds
  817: 	
  818:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
  819:         return pt()        
  820: 
  821:     def recalculateMetaLink(self):
  822:         """recalculate the metadata"""
  823:         
  824:         for entryid in self.__dict__:
  825:             entry=getattr(self,entryid)
  826:             if hasattr(entry,'meta_type'):
  827:                 
  828:                 if entry.meta_type=="ImageDigilib":
  829:                     entry.meta=entry.meta_default(entry.getId())
  830:         return "OK"
  831:     
  832:     def addImage(self):
  833:         """Add an Image"""
  834: 		
  835:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self)
  836:         return pt()
  837:     
  838:     def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):
  839:         """Add"""
  840: 
  841:         #print "FU",fileupload
  842: 
  843:         if use_default:
  844:             try:
  845:                 meta=self.meta_default(fileupload.filename)
  846:             except:
  847:                 meta=None
  848:         else:
  849:             meta=None
  850:         fn=splitPath(fileupload.filename)
  851: 	
  852:         manage_AddImageDigilib(self,fn,fileupload,meta=meta)
  853:         return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
  854:         #return  self.REQUEST['URL1']+'/'+fileupload.filename
  855: 
  856:     def ImportFiles2(self,RESPONSE=None):
  857:         """Import the existing files of a folder"""
  858:         files=os.listdir(self.ImageStoragePath)
  859:         ret=""
  860:         #print self.__dict__
  861:         for file in files:
  862:             if not file[0]==".":
  863:                 if self.__dict__.has_key(file):
  864: 
  865:                     ret=ret+"<br>"+file+" already exists!"
  866:                 else:
  867:                     ret=ret+"<br>"+file+" created!"
  868:                     meta=self.meta_default(file)
  869:                     newObj=ImageDigilib(file,file,meta)
  870:                     #print newObj,file
  871:                     #print newObj
  872:                     self._setObject(file,newObj)
  873:         #print ret
  874:         #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
  875:         #print self.ImageStoragePath
  876: 
  877:  	#scale thumb
  878: 	
  879:         self.scaleThumbs()
  880: 
  881: 	#scale standard
  882: 
  883: 	self.scaleWorkingVersions()
  884: 	
  885: 
  886:         RESPONSE.redirect('manage_main')
  887: 
  888:     def importStructure(self,path):
  889:         """import"""
  890:         splitted=os.path.split(path)
  891:         if os.path.isDir(path) and (len(splitted[1])>0) and (splitted[1][0]=="."):
  892:             manage_AddImageCollection(self,splitted[1],splitted[1],path,self.ImageViewerPath,self.defaultMetaString,RESPONSE=None)
  893:             
  894:             obj=getattr(self,splitted[1])
  895:             obj.ImportFiles()
  896: 
  897:     def ImportStructure(self,RESPONSE=None):
  898:         """Import the existing files of a folder"""
  899:         files=os.listdir(self.ImageStoragePath)
  900:         ret=""
  901:         #print self.__dict__
  902: 
  903: 
  904:         for file in files:
  905:             
  906:             if os.path.isdir(os.path.join(self.ImageStoragePath,file)):
  907:                 imageStoragePath=os.path.join(self.ImageStoragePath,file)
  908:                 imageViewerPath=os.path.join(self.ImageViewerPath,file)
  909:                 manage_AddImageCollection(self,file,file,imageStoragePath,imageViewerPath,self.defaultMetaString)
  910:             
  911:                 obj=getattr(self,file)
  912:                 obj.ImportStructure()
  913:             else:
  914:                 if not file[0]==".":
  915:                     if self.__dict__.has_key(file):
  916: 
  917:                         ret=ret+"<br>"+file+" already exists!"
  918:                     else:
  919:                         ret=ret+"<br>"+file+" created!"
  920:                         newObj=ImageDigilib(file,file)
  921:                         #print newObj,file
  922:                         #print newObj
  923:                         try:
  924:                             self._setObject(file,newObj)
  925:                         except:
  926:                             """nothing yet"""
  927:         #print ret
  928:         #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
  929:         #print self.ImageStoragePath
  930: 
  931: 		#scale thumb
  932: 	
  933:         #self.scaleThumbs()
  934: 
  935: 	#scale standard
  936: 
  937: 	#self.scaleWorkingVersions()
  938: 	
  939: 	if RESPONSE:
  940: 		RESPONSE.redirect('manage_main')
  941:     
  942:     def ImportFiles(self,RESPONSE=None):
  943:         """Import the existing files of a folder"""
  944:         files=os.listdir(self.ImageStoragePath)
  945:         ret=""
  946:         #print self.__dict__
  947:         for file in files:
  948:             if not file[0]==".":
  949:                 if self.__dict__.has_key(file):
  950: 
  951:                     ret=ret+"<br>"+file+" already exists!"
  952:                 else:
  953:                     ret=ret+"<br>"+file+" created!"
  954:                     newObj=ImageDigilib(file,file)
  955:                     #print newObj,file
  956:                     #print newObj
  957:                     try:
  958:                         self._setObject(file,newObj)
  959:                     except:
  960:                         """nothing yet"""
  961:         #print ret
  962:         #pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
  963:         #print self.ImageStoragePath
  964: 
  965: 		#scale thumb
  966: 	
  967:         self.scaleThumbs()
  968: 
  969: 	#scale standard
  970: 
  971: 	self.scaleWorkingVersions()
  972: 	
  973: 	if RESPONSE:
  974: 		RESPONSE.redirect('manage_main')
  975:         
  976:     def ImageCollection_config(self):
  977:         """Nothing yet"""
  978:         if not hasattr(self,'defaultMetaString'):
  979:             self.defaultMetaString=""
  980:             
  981:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeImageCollectionForm.zpt')).__of__(self)
  982:         return pt()
  983: 
  984:     def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
  985:         """Change"""
  986:         self.title=title
  987:         self.ImageStoragePath=ImageStoragePath
  988:         self.ImageViewerPath=ImageViewerPath
  989:         self.defaultMetaString=defaultMetaString
  990:         
  991:         if RESPONSE is not None:
  992:             RESPONSE.redirect('manage_main')
  993: 
  994:     def show_selected_thumbs(self):
  995:         #ids=[]
  996:         try:
  997:          return self.REQUEST.SESSION['filenames']
  998: 	except:
  999: 	 return None
 1000:     def show_thumbs(self):
 1001:         ids=[]
 1002:         for entry in self.__dict__:
 1003:             #print entry
 1004:             if hasattr(getattr(self,entry),'thumb'):
 1005:                 ids.append(entry)
 1006:                 
 1007:         #print ids
 1008:         ids.sort()
 1009:         return ids
 1010: 
 1011:     def firstSets(self,selected=None):
 1012:         ids=self.show_thumbs()
 1013:         if ids:
 1014:             if selected:
 1015:                 return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
 1016:             else:
 1017:                 return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
 1018: 
 1019:     def lastSets(self,selected=None):
 1020:         ids=self.show_thumbs()
 1021:         if ids:
 1022:             colRows=self.getColTimesRow()
 1023: 
 1024:             if colRows[1]:
 1025:                 nr=len(ids)-colRows[0]*colRows[1]
 1026:             else:
 1027:                 nr=0
 1028: 
 1029:             if nr<0:
 1030:                 nr=0
 1031: 
 1032:             if selected:
 1033:                 return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">last set</a>"
 1034:             else:
 1035:                 return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">last sets</a>"
 1036: 
 1037:         
 1038:                 
 1039:     def nextSets(self,selected=None):
 1040:         """show nextimage"""
 1041:         ids=self.show_thumbs()
 1042:         colRows=self.getColTimesRow()
 1043:         if ids:
 1044:             if colRows[1]:
 1045: 
 1046:                 if self.REQUEST.SESSION.has_key("filename"):
 1047:                     filename=self.REQUEST.SESSION["filename"]
 1048:                     try:
 1049:                         nr=ids.index(filename)+colRows[0]*colRows[1]
 1050:                         if nr>=len(ids):
 1051:                             nr=len(ids)-1
 1052:                     except:
 1053:                         nr=0
 1054:                 else:
 1055:                     nr=0
 1056: 
 1057:                 if nr==len(ids)-1:
 1058:                     return ""
 1059:                 else:
 1060:                     if selected:
 1061:                         return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
 1062:                     else:
 1063:                         return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
 1064: 
 1065:     def prevSets(self,selected=None):
 1066:         
 1067:         """show nextimage"""
 1068:         #return self.getId()
 1069:         ids=self.show_thumbs()
 1070:         colRows=self.getColTimesRow()
 1071:         if ids:
 1072:             if colRows[1]:
 1073:                 if self.REQUEST.SESSION.has_key("filename"):
 1074:                     filename=self.REQUEST.SESSION["filename"]
 1075:                     try:
 1076:                         nr=ids.index(filename)-colRows[0]*colRows[1]
 1077:                         if nr<0:
 1078:                             nr=0
 1079:                     except:
 1080:                         nr=0
 1081:                 else:
 1082:                     nr=0
 1083:                 try:
 1084:                     num=ids.index(filename)
 1085:                 except:
 1086:                     num=0
 1087: 
 1088:                 if num==0:
 1089:                     return ""
 1090:                 else:
 1091:                     if selected:
 1092:                         return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
 1093:                     else:
 1094:                         return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
 1095:             else:
 1096:                 return ""
 1097:     def showFolders(self):
 1098:         """show subfolders"""
 1099:         ret=""
 1100:         link=""" <a target="_top" href="%s">%s</a><br>"""
 1101: 
 1102:         if self.aq_parent.meta_type=="ImageCollection":
 1103:             ret+=link%(self.aq_parent.absolute_url(), "back ("+self.aq_parent.title+")")
 1104:             ret+="<br>"
 1105:             
 1106:         iCs=self.ZopeFind(self,obj_metatypes=["ImageCollection"])
 1107:         if not iCs:
 1108:             return ret
 1109:         else:
 1110:             
 1111:             link=""" <a target="_top" href="%s">%s</a><br>"""
 1112:             for iC in iCs:
 1113:                 ret+=link%(iC[1].absolute_url(),iC[0])
 1114:             ret+="<br>"
 1115:             return ret
 1116:     def showRuler(self,selected=None):
 1117:         """show ruler"""
 1118:         showall =self.REQUEST.SESSION.get('showall','no')
 1119:         ids=self.show_thumbs()
 1120:         if len(ids)==0:
 1121:             return "<b>No entries</b>"
 1122:         
 1123:         if showall=='no':
 1124: 	    actualNr=0
 1125:             ids=self.show_thumbs()
 1126:             colRows=self.getColTimesRow()
 1127:             num=int(len(ids)/(colRows[0]*colRows[1]))
 1128:             if not (operator.mod(len(ids),colRows[0]*colRows[1])==0):
 1129:                 num+=1
 1130:             a=colRows[0]*colRows[1]
 1131:             #print num,num+1
 1132: 		
 1133:             if num>1:
 1134: 
 1135:                 ret=""
 1136:                 if selected:
 1137: 	    		ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""/selection?filename='+this.options[this.selectedIndex].value">"""
 1138:                 else:
 1139: 			ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""?filename='+this.options[this.selectedIndex].value">"""
 1140: 		for i in range(num):
 1141: 			try:
 1142: 			  nr=ids.index(self.REQUEST.SESSION['filename'])
 1143: 			except:
 1144: 			  nr=0
 1145: 		        k=i*a	
 1146: 			if (k <= nr) and (nr < i*(a+1)):
 1147: 			   actualNr=i
 1148: 			   ret+="""<option value="%s" selected>%i</option>"""%(ids[k],i)
 1149: 			else:
 1150: 	    		   ret+="""<option value="%s">%i</option>"""%(ids[k],i)
 1151: 		ret+="</select>"	
 1152: 		anf="<b>Show thumbnail group no:</b></br>"
 1153: 		
 1154: 		
 1155: 		try:
 1156: 		  if selected:                
 1157:                         href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr-1)*a]
 1158:                   else:
 1159:                         href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr-1)*a)]
 1160: 		
 1161: 		  anf+="""<a href="%s" target="_top">%s</a>&nbsp;&nbsp;"""%(href,"prev")
 1162: 		except:
 1163: 		  pass
 1164: 		ret=anf+ret
 1165: 		
 1166: 		try:
 1167: 		  
 1168: 		  if selected:                
 1169:                         href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr+1)*a]
 1170:                   else:
 1171:                         href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr+1)*a)]
 1172: 		
 1173: 		  end="""<a href="%s" target="_top">%s</a>&nbsp;&nbsp;"""%(href,"next")
 1174: 		except:
 1175: 		  end=""
 1176: 		ret=ret+end
 1177: 
 1178: 
 1179:                 #for i in range(num):
 1180:                 #    
 1181:                 #        ret +="<br/>" #alle 10 linebreak einfuegen
 1182:                 #    k=i*a
 1183:                 #    if selected:                
 1184:                 #        href=self.REQUEST['URL1']+"/selection?filename="+ids[k]
 1185:                 #    else:
 1186:                 #        href=self.REQUEST['URL1']+"?filename="+ids[int(k)]
 1187: 	        #
 1188:                 #    ret+="""<a href="%s" target="_top">%i</a>&nbsp;&nbsp;"""%(href,i)
 1189: 
 1190:             else:
 1191:                 ret=""
 1192:             ret+="""<a href="%s?showall=yes" target="_top">show all</a> """%self.REQUEST['URL1']
 1193:         else:
 1194:             ret="""<a href="%s?showall=no" target="_top">show groups</a> """%self.REQUEST['URL1']
 1195: 
 1196:         return ret
 1197:     
 1198:     def show_thumbs_selected_rows(self,numberOfColumns):
 1199:         """Ausgabe anzahl"""
 1200:         ids=self.show_selected_thumbs()
 1201: 
 1202:         if not ids:
 1203: 		return None
 1204:         self.REQUEST.SESSION['ids']=ids
 1205:         number=int(len(ids)/numberOfColumns)+1
 1206:         self.REQUEST.SESSION['number']=range(number)
 1207:         return range(number+1)
 1208: 
 1209:     def setColTimesRowForm(self):
 1210:         """form for matrix setting"""
 1211:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','selectColTimesRow.zpt')).__of__(self)
 1212:         return pt()
 1213: 
 1214:     def setDone(self):
 1215:         """done"""
 1216:         
 1217:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changedColTimesRow.zpt')).__of__(self)
 1218:         return pt()
 1219: 
 1220:     def setColTimesRow(self,cols,rows):
 1221:         """set coltimes row"""
 1222:         RESPONSE=self.REQUEST.RESPONSE
 1223:         if not rows:
 1224:             rows=None
 1225:         if rows=="":
 1226:             rows=None
 1227: 
 1228:         if rows:
 1229:             RESPONSE.setCookie("ImageViewerRows",rows)
 1230:         RESPONSE.setCookie("ImageViewerCols",cols)
 1231: 
 1232:         RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")
 1233:         
 1234:     def getColTimesRow(self,showall='No'):
 1235:         """coltimesrow"""
 1236:         
 1237:         REQUEST=self.REQUEST
 1238:         """matrix"""
 1239:         if REQUEST.cookies.has_key("ImageViewerRows"):
 1240:             
 1241:             try:
 1242:                 rows=int(REQUEST.cookies["ImageViewerRows"])
 1243:             except:
 1244:                 rows=6
 1245:         else:
 1246:             rows=6
 1247:             
 1248:         if REQUEST.cookies.has_key("ImageViewerCols"):
 1249:             #print "COLS",REQUEST.cookies["ImageViewerCols"]
 1250:             cols=int(REQUEST.cookies["ImageViewerCols"])
 1251:         else:
 1252:             cols=2
 1253: 
 1254:         idsnumber=len(self.show_thumbs())
 1255:         if rows:
 1256:             if cols*rows >idsnumber:
 1257:                 rows=int(idsnumber/cols)+1
 1258: 
 1259:         #print cols,rows
 1260:         if showall=='yes':
 1261:             rows=int(idsnumber/cols)+1
 1262:             
 1263:         return (cols,rows)
 1264:                 
 1265:         
 1266:     def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None):
 1267:         """Ausgabe anzahl"""
 1268: 
 1269:         idsAll=self.show_thumbs()
 1270:         if len(idsAll)==0: #keine Einträge
 1271:             return 0
 1272:         if self.REQUEST.SESSION.has_key("filename"):
 1273:             filename=self.REQUEST.SESSION["filename"]
 1274:             filename=self.getImageByName(filename,onlyName="yes")
 1275:                 
 1276:             try:
 1277:                 startId=filename
 1278:                 if startId=="":
 1279:                     startId=idsAll[0][0:]    
 1280:             except:
 1281:                 startId=idsAll[0][0:]    
 1282:         else:
 1283:             startId=idsAll[0][0:]
 1284:             
 1285: 
 1286:         
 1287: 
 1288:         if numberOfRows:
 1289:            
 1290:             startPic=idsAll.index(startId)
 1291:             try:
 1292:                 
 1293:                 startPic=idsAll.index(startId)
 1294:                 endPic=startPic+numberOfColumns*numberOfRows
 1295:                 ids=idsAll[startPic:endPic]
 1296:             except:
 1297:                 ids=idsAll
 1298:         else:
 1299: 
 1300:             ids=idsAll
 1301: 
 1302:           
 1303:         self.REQUEST.SESSION['ids']=ids
 1304:         number=int(len(ids)/numberOfColumns)+1
 1305:     
 1306:         return range(number+1)
 1307: 
 1308:     def show_thumbs_columns(self,row,numberOfColumns):
 1309:         """Ausgabe einer Liste der Reihe"""
 1310:         ids=self.REQUEST.SESSION['ids']
 1311:         max=len(ids)
 1312:         if (row*numberOfColumns)<max:
 1313:             return ids[(row-1)*numberOfColumns:row*numberOfColumns]
 1314:         else:
 1315:             return ids[(row-1)*numberOfColumns:]
 1316:         
 1317:     def thumblistSelected_old(self):
 1318:         """main template collection"""
 1319:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected.zpt')).__of__(self)
 1320:         return pt()
 1321: 
 1322:     def thumblistSelected(self):
 1323:         """main template collection"""
 1324:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected2.zpt')).__of__(self)
 1325:         return pt()
 1326:     
 1327:     def thumblist_old(self):
 1328:         """main template collection"""
 1329:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)
 1330:         return pt()
 1331: 
 1332:     def thumblist(self):
 1333:         """main template collection"""
 1334:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb2.zpt')).__of__(self)
 1335:         return pt()
 1336: 
 1337:     def thumblistNewWindow(self):
 1338:         """Thumbs mit clik neues Fenster oeffnen"""
 1339:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbNewWindow.zpt')).__of__(self)
 1340:         return pt()
 1341:         
 1342: 
 1343:     def navig_selected_html(self):
 1344:         """navigation"""
 1345:         #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
 1346:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation_selected.zpt')).__of__(self)
 1347:         return pt()
 1348: 
 1349:     def navig_html(self):
 1350:         """navigation"""
 1351:         #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
 1352:        
 1353:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','navigation.zpt')).__of__(self)
 1354:         return pt()
 1355: 
 1356: 
 1357:     def selection(self):
 1358:         """show only selected"""
 1359:         if self.REQUEST.has_key('filename'):
 1360:             filen=self.REQUEST['filename']
 1361:         else:
 1362:             filen=""
 1363:         self.REQUEST.SESSION['filename']=filen
 1364:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected2.zpt')).__of__(self)
 1365:         return pt()  
 1366: 
 1367:     def getImageByName(self,filename,onlyName=None):
 1368:         """get filename"""
 1369:         
 1370:         fn=getattr(self,filename,None)
 1371:         if not fn:
 1372:             filenameM=filename.split(".")[0]
 1373:             founds=self.ZopeFind(self,obj_metatypes=['ImageDigilib'])
 1374:             for found in founds:
 1375:                 foundM=found[0].split(".")[0]
 1376:                 if filenameM.lower()==foundM.lower():
 1377:                     if onlyName:
 1378:                         return found[0]
 1379:                     else:
 1380:                         return found[1]
 1381:         if onlyName:
 1382:             return filename
 1383:         else:
 1384:             return fn
 1385:     def index_html(self):
 1386:         """main template collection"""
 1387:         if self.REQUEST.has_key('filename'):
 1388:             filen=self.REQUEST['filename']
 1389:         else:
 1390:             filen=""
 1391: 
 1392:         self.REQUEST.SESSION['filename']=filen[0:]
 1393: 
 1394:         if self.REQUEST.has_key('showall'):
 1395: 
 1396:             self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
 1397:         else:
 1398:             self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
 1399:             
 1400:      
 1401:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__of__(self)
 1402:         return pt()
 1403:     
 1404: def manage_AddImageCollectionForm(self):
 1405:     """Nothing yet"""
 1406:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionForm.zpt')).__of__(self)
 1407:     return pt()
 1408:     
 1409: def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
 1410:     """Add ImageCollection"""
 1411:     newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
 1412:     self._setObject(id,newObj)
 1413:     
 1414:     if RESPONSE is not None:
 1415:         RESPONSE.redirect('manage_main')
 1416: 
 1417: 
 1418: class ImageCollectionIFrame(ImageCollection):
 1419:     """Class fuer Collection set als IFrame"""
 1420: 
 1421:     meta_type="ImageCollectionIFrame"
 1422:     label=ImageCollection.title
 1423: 
 1424:     def getImageTag(self):
 1425:         """ hack : method needed by echo_content"""
 1426:         return ""
 1427:     
 1428:     def rotate(self,angle,url,RESPONSE):
 1429: 	"""rotate"""
 1430: 	
 1431: 	RESPONSE.redirect("javascript:document.domain='mpg.de';parent.iframe.right.rotation(%i)"%int(angle))
 1432: 	RESPONSE.redirect(url)
 1433:     def request(self):
 1434:         """request"""
 1435:         return self.REQUEST
 1436:         
 1437:     def index_html(self):
 1438:         """index"""
 1439:         if self.REQUEST.has_key('filename'):
 1440:             filen=self.REQUEST['filename']
 1441:         else:
 1442:             filen=""
 1443:         self.REQUEST.SESSION['filename']=filen
 1444:         
 1445:     
 1446:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameMain.zpt')).__of__(self)
 1447:         return pt()
 1448: 
 1449:     def iframe_html(self):
 1450:         """iframe"""
 1451:         if self.REQUEST.has_key('filename'):
 1452:             filen=self.REQUEST['filename']
 1453:         else:
 1454:             filen=""
 1455:         self.REQUEST.response.setCookie('filename',filen)
 1456:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameOverview.zpt')).__of__(self)
 1457:         return pt()
 1458: 
 1459: 
 1460: def manage_AddImageCollectionIFrameForm(self):
 1461:     """Nothing yet"""
 1462:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionIFrameForm.zpt')).__of__(self)
 1463:     return pt()
 1464:     
 1465: def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
 1466:     """Add ImageCollection"""
 1467:     newObj=ImageCollectionIFrame(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
 1468:     self._setObject(id,newObj)
 1469:     
 1470:     if RESPONSE is not None:
 1471:         RESPONSE.redirect('manage_main')
 1472: 
 1473: 

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>