1: from OFS.Folder import Folder
2: from OFS.SimpleItem import SimpleItem
3: from Globals import Persistent
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:
16: def splitPath(str):
17: str2=str.replace("\\","/")
18: return os.path.split(str2)[1]
19:
20: def getText(nodelist):
21:
22: rc = ""
23: for node in nodelist:
24:
25: if node.nodeType == node.TEXT_NODE:
26: rc = rc + node.data
27: return rc
28:
29:
30: class ImageDigilib(Folder,Persistent,Implicit):
31: """Anzeige object fuer digilib"""
32: meta_type="ImageDigilib"
33:
34: leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
35:
36: manage_options = Folder.manage_options+(
37:
38: {'label':'Add Metadata','action':'addMetaObjectForm'},
39:
40: )
41:
42: def addMetaObject(self,id,RESPONSE=None):
43: """Add an MetaObject"""
44: objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
45:
46: request=self.REQUEST
47: objectCreate=objectType.createObjectManager(id,request)
48:
49: self._setObject(id,objectCreate)
50:
51: objectCreate.propertysheets.meta.manage_editProperties(request)
52:
53: if RESPONSE is not None:
54: RESPONSE.redirect('manage_main')
55:
56:
57:
58:
59: def addMetaObjectForm(self):
60: """Add Form"""
61: pt=PageTemplateFile('Products/ImageArchive/zpt/addMetaObject.zpt').__of__(self)
62: return pt()
63:
64:
65: def __init__(self,id,filename,meta=None):
66: self.id=id
67: self.title=filename
68: self.filename=filename
69: self.meta=meta
70:
71: def getMeta(self):
72: """ausgabe der metadaten"""
73: return self.meta
74:
75: def uploadImage(self,fileupload,path_name):
76: """upload an Image from an Requast"""
77: #path_name=self.ImageStoragePath
78: fn=splitPath(fileupload.filename)
79: filename=path_name+"/"+fn
80: filedata=fileupload.read()
81: f=open(filename,"w")
82: f.write(filedata)
83: f.close()
84: try:
85: os.chmod(filename,0644)
86: except:
87: """hack"""
88: #scale thumb
89:
90: self.scaleThumbs()
91:
92: #scale standard
93:
94: self.scaleWorkingVersions()
95:
96:
97: def downloadWorkingVersion(self):
98: """download working version (2000 pixel)"""
99:
100: return self.download(fmt="&dw=2000&dh=2000",suffix=".jpg")
101:
102: def download(self,fmt="&mo=rawfile,hires",suffix=None):
103: """download"""
104: path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]+fmt
105:
106: if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(self.filename):
107: filename=self.REQUEST.SESSION['filenamesIds'][self.filename][0]+"_"+self.filename
108: else:
109: filename=self.filename
110:
111: if suffix:
112: filename=os.path.splitext(filename)[0]+suffix
113:
114: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)
115: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
116: image=urllib.urlopen(path).read()
117: self.REQUEST.RESPONSE.write(image)
118: self.REQUEST.RESPONSE.close()
119: #return self.REQUEST.RESPONSE.redirect(path)
120:
121: def thumb(self):
122: """show thumb"""
123: thumbname=os.path.splitext(self.filename)[0]+".jpg"
124: ## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):
125: ## image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:18080/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150&mo=lores").read()
126: ## f=open("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname,"w")
127: ## f.write(image)
128: ## f.close()
129: ## os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 150 &"% self.ImageViewerPath)
130:
131: #DEVEL:take nausikaa for server solution
132:
133: 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"
134: #path="/mpiwg/online/"+self.ImageViewerPath+"/"+thumbname
135: self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
136: pt=PageTemplateFile('Products/ImageArchive/zpt/thumb.zpt').__of__(self)
137: return pt()
138:
139: def index_html(self):
140: """show image"""
141: #DEVELOP: take first one for server
142:
143: path="http://content.mpiwg-berlin.mpg.de/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+self.filename
144:
145: #path="http://localhost:8080/mpiwg/online/"+self.ImageViewerPath+"/"+self.filename
146: #self.REQUEST.SESSION['string']="<img src=\"%s\">"% path
147: #pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)
148: return self.REQUEST.RESPONSE.redirect(path)
149:
150:
151: def manage_AddImageDigilibForm(self):
152: """Nothing yet"""
153: pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageDigilibForm.zpt').__of__(self)
154: return pt()
155:
156: def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
157: """Add ImageCollection"""
158: #fileupload=self.REQUEST['fileupload']
159: fn=splitPath(fileupload.filename)
160: newObj=ImageDigilib(id,fn,meta)
161:
162: self._setObject(id,newObj)
163: getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
164:
165: if RESPONSE is not None:
166: RESPONSE.redirect('manage_main')
167:
168:
169: class ImageCollection(Folder, Persistent, Implicit):
170: """Sammelordner für Bilder"""
171: meta_type="ImageCollection"
172:
173: genericMetaDataType="leiden_meta"
174:
175: leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
176:
177:
178: 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
179:
180:
181:
182: def createSet(self,RESPONSE=None,local=None,version="working"):
183: """download aller gewaehlten files"""
184: tempfile.tempdir="/tmp/archivesImageServer"
185:
186: tmpPath=tempfile.mktemp()
187:
188:
189: tmpZip=tempfile.mktemp()+".zip"
190: tmpFn=os.path.split(tmpZip)[1]
191:
192:
193: if not os.path.exists(tempfile.tempdir):
194: os.mkdir(tempfile.tempdir)
195:
196: if not os.path.exists(tmpPath):
197: os.mkdir(tmpPath)
198:
199:
200: if RESPONSE:
201: RESPONSE.setHeader("Content-Type","text/html")
202: RESPONSE.write("<h1>I am creating the download archive</h1>")
203: RESPONSE.write("<h3>1. step: getting the images</h3>")
204:
205: if not self.REQUEST.SESSION.has_key('filenames'):
206: RESPONSE.write("<h2>ERROR</h2>")
207: RESPONSE.write("<p>I forgot, the selected files. Please reselect.\n")
208: return 0
209:
210: for id in self.REQUEST.SESSION['filenames']:
211:
212: if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(id[0]):
213: filename=self.REQUEST.SESSION['filenamesIds'][id[0]][0]+"_"+id[0]
214: else:
215: filename=id[0]
216:
217: if RESPONSE:
218: RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))
219:
220: if local:
221: if version=="working":
222: sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+id[0]
223: else:
224: sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]
225: targetPath=tmpPath+"/"+filename
226: try:
227: shutil.copyfile(sourcePath,targetPath)
228: except:
229: if RESPONSE:
230: RESPONSE.write(str("<p>Error in File: %s (possible missing)<br>\n"%filename))
231: else:
232: """nothing"""
233: else:
234: if version=="working":
235: 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"
236: else:
237: path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(urllib.quote(id[0]))[0]+"&mo=rawfile,hires"
238: image=urllib.urlopen(path).read()
239:
240:
241: fh=file(tmpPath+"/"+filename,"w")
242:
243:
244: fh.write(image)
245: fh.close()
246:
247: #folgeseiten
248: if int(self.REQUEST.SESSION['filenamesIds'][id[0]][1])>1:
249: ids=self.show_thumbs()
250: nr=ids.index(id[0])
251:
252: numberOfPages=self.REQUEST.SESSION['filenamesIds'][id[0]][1]
253: for k in range(int(numberOfPages)-1):
254: i=k+1
255: if self.REQUEST.SESSION.has_key('filenamesIds') and self.REQUEST.SESSION['filenamesIds'].has_key(id[0]):
256: filename=self.REQUEST.SESSION['filenamesIds'][id[0]][0]+"_"+ids[nr+i]
257: else:
258: filename=id[0]
259:
260: if RESPONSE:
261: RESPONSE.write(str("<p>Get File: %s<br>\n"%filename))
262:
263: if local:
264: sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+ids[nr+1]
265: targetPath=tmpPath+"/"+filename
266: try:
267: shutil.copyfile(sourcePath,targetPath)
268: except:
269: if RESPONSE:
270: RESPONSE.write(str("<p>Error in File: %s (missing?)<br>\n"%filename))
271: else:
272: """nothing"""
273: else:
274: path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+os.path.splitext(ids[nr+i])[0]+"&mo=rawfile,hires"
275:
276: image=urllib.urlopen(path).read()
277:
278:
279: fh=file(tmpPath+"/"+filename,"w")
280: fh.write(image)
281: fh.close()
282:
283: if RESPONSE:
284: RESPONSE.write("<h3>2. step: creating the downloadable file</h3>")
285: RESPONSE.write("<p>Create Zip<br>")
286: RESPONSE.write("<p>This can take a while....<br>\n")
287: if RESPONSE:
288: fh=os.popen2("zip -u %s %s/*"%(tmpZip,tmpPath),1)[1]
289: RESPONSE.write("<br>")
290: for c in fh.read():
291: RESPONSE.write(c)
292:
293: if c==")":
294: RESPONSE.write("<br>\n")
295:
296:
297: else:
298: os.popen("zip -u %s %s/*"%(tmpZip,tmpPath))
299:
300:
301: shutil.rmtree(tmpPath)
302:
303: if RESPONSE:
304: RESPONSE.write("<p>finished<br>\n")
305:
306: if RESPONSE:
307: len=os.stat(tmpZip)[6]
308: downloadUrl=self.absolute_url()+"/downloadSet"
309: RESPONSE.write("""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
310: RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
311: <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
312: RESPONSE.close()
313:
314: def downloadSet(self,fn):
315: """download prepared set"""
316: filename="/tmp/archivesImageServer/"+fn
317:
318: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"image.zip")
319: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
320: len=os.stat(filename)[6]
321: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
322: images=file(filename).read()
323: self.REQUEST.RESPONSE.write(images)
324: self.REQUEST.RESPONSE.close()
325:
326:
327:
328: def scaleThumbs(self,RESPONSE=None):
329: """scale thumbs"""
330:
331: #scale thumbs
332: 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)
333: if RESPONSE:
334: RESPONSE.write(ret.read())
335: RESPONSE.write("\n")
336:
337: return "RESCALING STARTED"
338:
339: def scaleWorkingVersions(self,RESPONSE=None):
340: """scale working versions"""
341:
342: #scale standard
343:
344: 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)
345: if RESPONSE:
346: RESPONSE.write(ret.read())
347: RESPONSE.write("\n")
348: return "rescaling started"
349:
350:
351:
352: def __init__(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString):
353: self.id=id
354: self.title=title
355: self.ImageStoragePath=ImageStoragePath
356: self.ImageViewerPath=ImageViewerPath
357: self.defaultMetaString=defaultMetaString
358:
359: manage_options = Folder.manage_options+(
360: {'label':'Main Config','action':'ImageCollection_config'},
361: {'label':'Import','action':'ImportFiles'},
362: {'label':'Recalculate Metadata','action':'recalculateMeta'},
363: {'label':'Import Metadata','action':'importMetaForm'},
364: {'label':'Rescale thumbs','action':'scaleThumbs'},
365: {'label':'Rescale working version','action':'scaleWorkingVersions'},
366: {'label':'Weight (ECHO)','action':'weightForm'},
367: )
368:
369: def weightForm(self):
370: """Weight"""
371: pt=PageTemplateFile('Products/ImageArchive/zpt/changeWeight.zpt').__of__(self)
372: return pt()
373:
374: def changeWeight(self,weight,RESPONSE=None):
375: """Change weight"""
376: self.weight=weight
377:
378: if RESPONSE is not None:
379: RESPONSE.redirect('manage_main')
380:
381:
382: def importMetaForm(self):
383: """import metadata"""
384: pt=PageTemplateFile('Products/ImageArchive/zpt/importMeta.zpt').__of__(self)
385: return pt()
386:
387: def importMeta(self,fileupload,tag):
388: """import"""
389: filedata=fileupload.read()
390: dom=xml.dom.minidom.parseString(filedata)
391: rows=dom.getElementsByTagName(tag)
392: #print "ROWS",rows
393: request=self.REQUEST
394: for row in rows:
395:
396: for a in self.leiden_meta_fields:
397: self.REQUEST[a]=getText(row.getElementsByTagName(a)[0].childNodes)
398:
399: image_id=self.REQUEST['image_id']
400: if (not hasattr(self,image_id)) & (not image_id==""):
401: #print image_id
402: newObj=ImageCollection(str(image_id),image_id,'','','')
403: self._setObject(str(image_id),newObj)
404:
405: id="leiden_meta_data_file"
406: self.REQUEST['id']=id
407: #objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
408: #objectCreate=objectType.createInObjectManager(id,request)
409: #href="http://localhost:8080/tests/testcollection/manage_addProduct/ImageMetaData/leiden_meta_factory/"
410: try:
411: addID=getattr(self,image_id)
412: objectCreate=addID.manage_addProduct['ImageMetaData'].leiden_meta_add(id)
413: #getattr(self,image_id)._setObject(id,objectCreate)
414: obj=getattr(addID,id)
415: obj.propertysheets.meta.manage_editProperties(request)
416: except:
417: """nothing"""
418: return "OK"
419:
420:
421: def nextImage(self,request,selected=None,returnFn=None):
422: """show nextimage"""
423: try:
424: ids=self.show_thumbs()
425: if request.SESSION.has_key("filename"):
426: filename=request.SESSION["filename"]
427: try:
428: nr=ids.index(filename)
429:
430: except:
431: nr=0
432: else:
433: nr=0
434:
435: if nr==len(ids)-1:
436: return ""
437: else:
438: if returnFn:
439: return ids[nr+1]
440:
441: if selected:
442: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
443: else:
444: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
445: except:
446: return ""
447:
448: def prevImage(self,request,selected=None):
449: """show nextimage"""
450: #return self.getId()
451: try:
452: ids=self.show_thumbs()
453: if request.SESSION.has_key("filename"):
454: filename=request.SESSION["filename"]
455: try:
456: nr=ids.index(filename)
457: except:
458: nr=0
459: else:
460: nr=0
461:
462: if nr==0:
463: return ""
464: else:
465: if selected:
466: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
467: else:
468: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
469: except:
470: return ""
471:
472: def meta_default(self,filename):
473: """url der metadaten"""
474: return self.defaultMetaString % filename
475:
476: def getThumbAttribute(self,id,attr):
477: if hasattr(self,id):
478: return getattr(getattr(self,id),attr)
479: else:
480: if attr=='title':
481: return "<b>Missing Image:%s</b>" % id
482:
483: def getThumbFunction(self,id,attr):
484: #return "DUMP"
485: if hasattr(self,id):
486: return getattr(getattr(self,id),attr)()
487:
488:
489: def xmlinput(self,url):
490: """Anzeige von ausgewaehlten thumbs"""
491: #return url
492:
493: url=urllib.unquote(url)
494: xmldoc=urllib.urlopen(url).read()
495: #print url
496: try:
497: dom=xml.dom.minidom.parseString(xmldoc)
498: except:
499: return xmldoc
500: images=dom.getElementsByTagName('image')
501:
502: rc=[]
503: fnIds={}
504: for image in images:
505: imagename=image.getElementsByTagName('imagename')[0]
506: text=getText(imagename.childNodes)
507: idnr=image.getElementsByTagName('idnr')[0]
508: id=getText(idnr.childNodes)
509: numberOfPages=image.getElementsByTagName('numberOfPages')[0]
510: nopT=getText(numberOfPages.childNodes)
511: try:
512: nop=int(nopT)
513: except:
514: nop=0
515: if not text=="":
516: rc.append((str(text),id,nop))
517: fnIds[str(text)]=(id,nop)
518: rc.sort()
519: self.REQUEST.SESSION['filenames']=rc
520: self.REQUEST.SESSION['filenamesIds']=fnIds
521:
522: pt=PageTemplateFile('Products/ImageArchive/zpt/overview_selected.zpt').__of__(self)
523: return pt()
524:
525: def recalculateMeta(self):
526: """recalculate the metadata"""
527:
528: for entryid in self.__dict__:
529: entry=getattr(self,entryid)
530: if hasattr(entry,'meta_type'):
531:
532: if entry.meta_type=="ImageDigilib":
533: entry.meta=entry.meta_default(entry.getId())
534: return "OK"
535:
536: def addImage(self):
537: """Add an Image"""
538: pt=PageTemplateFile('Products/ImageArchive/zpt/addImage.zpt').__of__(self)
539: return pt()
540:
541: def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):
542: """Add"""
543: #print "FU",fileupload
544:
545: if use_default:
546: try:
547: meta=self.meta_default(fileupload.filename)
548: except:
549: meta=None
550: else:
551: meta=None
552: fn=splitPath(fileupload.filename)
553:
554: manage_AddImageDigilib(self,fn,fileupload,meta=meta)
555: return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fn)
556: #return self.REQUEST['URL1']+'/'+fileupload.filename
557:
558: def ImportFiles2(self,RESPONSE=None):
559: """Import the existing files of a folder"""
560: files=os.listdir(self.ImageStoragePath)
561: ret=""
562: #print self.__dict__
563: for file in files:
564: if not file[0]==".":
565: if self.__dict__.has_key(file):
566:
567: ret=ret+"<br>"+file+" already exists!"
568: else:
569: ret=ret+"<br>"+file+" created!"
570: meta=self.meta_default(file)
571: newObj=ImageDigilib(file,file,meta)
572: #print newObj,file
573: #print newObj
574: self._setObject(file,newObj)
575: #print ret
576: #pt=PageTemplateFile('Products/ImageArchive/out.zpt').__of__(self)
577: #print self.ImageStoragePath
578:
579: #scale thumb
580:
581: self.scaleThumbs()
582:
583: #scale standard
584:
585: self.scaleWorkingVersions()
586:
587:
588: RESPONSE.redirect('manage_main')
589:
590: def ImportFiles(self,RESPONSE=None):
591: """Import the existing files of a folder"""
592: files=os.listdir(self.ImageStoragePath)
593: ret=""
594: #print self.__dict__
595: for file in files:
596: if not file[0]==".":
597: if self.__dict__.has_key(file):
598:
599: ret=ret+"<br>"+file+" already exists!"
600: else:
601: ret=ret+"<br>"+file+" created!"
602: newObj=ImageDigilib(file,file)
603: #print newObj,file
604: #print newObj
605: try:
606: self._setObject(file,newObj)
607: except:
608: """nothing yet"""
609: #print ret
610: #pt=PageTemplateFile('Products/ImageArchive/out.zpt').__of__(self)
611: #print self.ImageStoragePath
612:
613: #scale thumb
614:
615: self.scaleThumbs()
616:
617: #scale standard
618:
619: self.scaleWorkingVersions()
620:
621: if RESPONSE:
622: RESPONSE.redirect('manage_main')
623:
624: def ImageCollection_config(self):
625: """Nothing yet"""
626: if not hasattr(self,'defaultMetaString'):
627: self.defaultMetaString=""
628:
629: pt=PageTemplateFile('Products/ImageArchive/zpt/ChangeImageCollectionForm.zpt').__of__(self)
630: return pt()
631:
632: def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
633: """Change"""
634: self.title=title
635: self.ImageStoragePath=ImageStoragePath
636: self.ImageViewerPath=ImageViewerPath
637: self.defaultMetaString=defaultMetaString
638:
639: if RESPONSE is not None:
640: RESPONSE.redirect('manage_main')
641:
642: def show_selected_thumbs(self):
643: #ids=[]
644:
645: return self.REQUEST.SESSION['filenames']
646:
647: def show_thumbs(self):
648: ids=[]
649: for entry in self.__dict__:
650: #print entry
651: if hasattr(getattr(self,entry),'thumb'):
652: ids.append(entry)
653:
654: #print ids
655: ids.sort()
656: return ids
657:
658: def firstSets(self,selected=None):
659: ids=self.show_thumbs()
660: if ids:
661: if selected:
662: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
663: else:
664: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
665:
666: def lastSets(self,selected=None):
667: ids=self.show_thumbs()
668: if ids:
669: colRows=self.getColTimesRow()
670:
671: if colRows[1]:
672: nr=len(ids)-colRows[0]*colRows[1]
673: else:
674: nr=0
675:
676: if nr<0:
677: nr=0
678:
679: if selected:
680: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">last set</a>"
681: else:
682: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">last sets</a>"
683:
684:
685:
686: def nextSets(self,selected=None):
687: """show nextimage"""
688: ids=self.show_thumbs()
689: colRows=self.getColTimesRow()
690: if ids:
691: if colRows[1]:
692:
693: if self.REQUEST.SESSION.has_key("filename"):
694: filename=self.REQUEST.SESSION["filename"]
695: try:
696: nr=ids.index(filename)+colRows[0]*colRows[1]
697: if nr>=len(ids):
698: nr=len(ids)-1
699: except:
700: nr=0
701: else:
702: nr=0
703:
704: if nr==len(ids)-1:
705: return ""
706: else:
707: if selected:
708: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
709: else:
710: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
711:
712: def prevSets(self,selected=None):
713:
714: """show nextimage"""
715: #return self.getId()
716: ids=self.show_thumbs()
717: colRows=self.getColTimesRow()
718: if ids:
719: if colRows[1]:
720: if self.REQUEST.SESSION.has_key("filename"):
721: filename=self.REQUEST.SESSION["filename"]
722: try:
723: nr=ids.index(filename)-colRows[0]*colRows[1]
724: if nr<0:
725: nr=0
726: except:
727: nr=0
728: else:
729: nr=0
730: try:
731: num=ids.index(filename)
732: except:
733: num=0
734:
735: if num==0:
736: return ""
737: else:
738: if selected:
739: return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
740: else:
741: return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
742: else:
743: return ""
744:
745: def showRuler(self,selected=None):
746: """show ruler"""
747: showall =self.REQUEST.SESSION.get('showall','no')
748: ids=self.show_thumbs()
749: if len(ids)==0:
750: return "<b>No entries</b>"
751:
752: if showall=='no':
753: ids=self.show_thumbs()
754: colRows=self.getColTimesRow()
755: num=int(len(ids)/(colRows[0]*colRows[1]))
756: if not (operator.mod(len(ids),colRows[0]*colRows[1])==0):
757: num+=1
758: a=colRows[0]*colRows[1]
759: #print num,num+1
760: if num>1:
761:
762: ret="<b>Show thumbnail group no:</b></br>"
763: for i in range(num):
764: if (operator.mod(i,10)==0) and i>0:
765: ret +="<br/>" #alle 10 linebreak einfuegen
766: k=i*a
767: if selected:
768: href=self.REQUEST['URL1']+"/selection?filename="+ids[k]
769: else:
770: href=self.REQUEST['URL1']+"?filename="+ids[int(k)]
771:
772: ret+="""<a href="%s" target="_top">%i</a> """%(href,i)
773:
774: else:
775: ret=""
776: ret+="""<a href="%s?showall=yes" target="_top">show all</a> """%self.REQUEST['URL1']
777: else:
778: ret="""<a href="%s?showall=no" target="_top">show groups</a> """%self.REQUEST['URL1']
779:
780: return ret
781:
782: def show_thumbs_selected_rows(self,numberOfColumns):
783: """Ausgabe anzahl"""
784: ids=self.show_selected_thumbs()
785: self.REQUEST.SESSION['ids']=ids
786: number=int(len(ids)/numberOfColumns)+1
787: self.REQUEST.SESSION['number']=range(number)
788: return range(number+1)
789:
790: def setColTimesRowForm(self):
791: """form for matrix setting"""
792: pt=PageTemplateFile('Products/ImageArchive/zpt/selectColTimesRow.zpt').__of__(self)
793: return pt()
794:
795: def setDone(self):
796: """done"""
797:
798: pt=PageTemplateFile('Products/ImageArchive/zpt/changedColTimesRow.zpt').__of__(self)
799: return pt()
800:
801: def setColTimesRow(self,cols,rows):
802: """set coltimes row"""
803: RESPONSE=self.REQUEST.RESPONSE
804: if not rows:
805: rows=None
806: if rows=="":
807: rows=None
808:
809: if rows:
810: RESPONSE.setCookie("ImageViewerRows",rows)
811: RESPONSE.setCookie("ImageViewerCols",cols)
812:
813: RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")
814:
815: def getColTimesRow(self,showall='No'):
816: """coltimesrow"""
817:
818: REQUEST=self.REQUEST
819: """matrix"""
820: if REQUEST.cookies.has_key("ImageViewerRows"):
821:
822: try:
823: rows=int(REQUEST.cookies["ImageViewerRows"])
824: except:
825: rows=6
826: else:
827: rows=6
828:
829: if REQUEST.cookies.has_key("ImageViewerCols"):
830: #print "COLS",REQUEST.cookies["ImageViewerCols"]
831: cols=int(REQUEST.cookies["ImageViewerCols"])
832: else:
833: cols=2
834:
835: idsnumber=len(self.show_thumbs())
836: if rows:
837: if cols*rows >idsnumber:
838: rows=int(idsnumber/cols)+1
839:
840: #print cols,rows
841: if showall=='yes':
842: rows=int(idsnumber/cols)+1
843:
844: return (cols,rows)
845:
846:
847: def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None):
848: """Ausgabe anzahl"""
849:
850: idsAll=self.show_thumbs()
851: if len(idsAll)==0: #keine Einträge
852: return 0
853: if self.REQUEST.SESSION.has_key("filename"):
854: filename=self.REQUEST.SESSION["filename"]
855:
856:
857: try:
858: startId=filename
859: if startId=="":
860: startId=idsAll[0][0:]
861: except:
862: startId=idsAll[0][0:]
863: else:
864: startId=idsAll[0][0:]
865:
866:
867:
868:
869: if numberOfRows:
870:
871: startPic=idsAll.index(startId)
872: try:
873:
874: startPic=idsAll.index(startId)
875: endPic=startPic+numberOfColumns*numberOfRows
876: ids=idsAll[startPic:endPic]
877: except:
878: ids=idsAll
879: else:
880:
881: ids=idsAll
882:
883:
884: self.REQUEST.SESSION['ids']=ids
885: number=int(len(ids)/numberOfColumns)+1
886:
887: return range(number+1)
888:
889: def show_thumbs_columns(self,row,numberOfColumns):
890: """Ausgabe einer Liste der Reihe"""
891: ids=self.REQUEST.SESSION['ids']
892: max=len(ids)
893: if (row*numberOfColumns)<max:
894: return ids[(row-1)*numberOfColumns:row*numberOfColumns]
895: else:
896: return ids[(row-1)*numberOfColumns:]
897:
898: def thumblistSelected_old(self):
899: """main template collection"""
900: pt=PageTemplateFile('Products/ImageArchive/zpt/thumbselected.zpt').__of__(self)
901: return pt()
902:
903: def thumblistSelected(self):
904: """main template collection"""
905: pt=PageTemplateFile('Products/ImageArchive/zpt/thumbselected2.zpt').__of__(self)
906: return pt()
907:
908: def thumblist_old(self):
909: """main template collection"""
910: pt=PageTemplateFile('Products/ImageArchive/zpt/thumbs.zpt').__of__(self)
911: return pt()
912:
913: def thumblist(self):
914: """main template collection"""
915: pt=PageTemplateFile('Products/ImageArchive/zpt/thumb2.zpt').__of__(self)
916: return pt()
917:
918: def thumblistNewWindow(self):
919: """Thumbs mit clik neues Fenster oeffnen"""
920: pt=PageTemplateFile('Products/ImageArchive/zpt/thumbNewWindow.zpt').__of__(self)
921: return pt()
922:
923:
924: def navig_selected_html(self):
925: """navigation"""
926: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
927: pt=PageTemplateFile('Products/ImageArchive/zpt/navigation_selected.zpt').__of__(self)
928: return pt()
929:
930: def navig_html(self):
931: """navigation"""
932: #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
933: pt=PageTemplateFile('Products/ImageArchive/zpt/navigation.zpt').__of__(self)
934: return pt()
935:
936:
937: def selection(self):
938: """show only selected"""
939: if self.REQUEST.has_key('filename'):
940: filen=self.REQUEST['filename']
941: else:
942: filen=""
943: self.REQUEST.SESSION['filename']=filen
944: pt=PageTemplateFile('Products/ImageArchive/zpt/overview_selected2.zpt').__of__(self)
945: return pt()
946:
947: def index_html(self):
948: """main template collection"""
949: if self.REQUEST.has_key('filename'):
950: filen=self.REQUEST['filename']
951: else:
952: filen=""
953:
954: self.REQUEST.SESSION['filename']=filen
955:
956: if self.REQUEST.has_key('showall'):
957:
958: self.REQUEST.SESSION['showall']=self.REQUEST.get('showall')
959: else:
960: self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')
961:
962:
963: pt=PageTemplateFile('Products/ImageArchive/zpt/overview.zpt').__of__(self)
964: return pt()
965:
966: def manage_AddImageCollectionForm(self):
967: """Nothing yet"""
968: pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageCollectionForm.zpt').__of__(self)
969: return pt()
970:
971: def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
972: """Add ImageCollection"""
973: newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
974: self._setObject(id,newObj)
975:
976: if RESPONSE is not None:
977: RESPONSE.redirect('manage_main')
978:
979:
980: class ImageCollectionIFrame(ImageCollection):
981: """Class fuer Collection set als IFrame"""
982:
983: meta_type="ImageCollectionIFrame"
984: label=ImageCollection.title
985:
986: def getImageTag(self):
987: """ hack : method needed by echo_content"""
988: return ""
989:
990: def rotate(self,angle,url,RESPONSE):
991: """rotate"""
992:
993: RESPONSE.redirect("javascript:document.domain='mpg.de';parent.iframe.right.rotation(%i)"%int(angle))
994: RESPONSE.redirect(url)
995: def request(self):
996: """request"""
997: return self.REQUEST
998:
999: def index_html(self):
1000: """index"""
1001: if self.REQUEST.has_key('filename'):
1002: filen=self.REQUEST['filename']
1003: else:
1004: filen=""
1005: self.REQUEST.SESSION['filename']=filen
1006:
1007:
1008: pt=PageTemplateFile('Products/ImageArchive/zpt/IFrameMain.zpt').__of__(self)
1009: return pt()
1010:
1011: def iframe_html(self):
1012: """iframe"""
1013: if self.REQUEST.has_key('filename'):
1014: filen=self.REQUEST['filename']
1015: else:
1016: filen=""
1017: self.REQUEST.response.setCookie('filename',filen)
1018: pt=PageTemplateFile('Products/ImageArchive/zpt/IFrameOverview.zpt').__of__(self)
1019: return pt()
1020:
1021:
1022: def manage_AddImageCollectionIFrameForm(self):
1023: """Nothing yet"""
1024: pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageCollectionIFrameForm.zpt').__of__(self)
1025: return pt()
1026:
1027: def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
1028: """Add ImageCollection"""
1029: newObj=ImageCollectionIFrame(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
1030: self._setObject(id,newObj)
1031:
1032: if RESPONSE is not None:
1033: RESPONSE.redirect('manage_main')
1034:
1035:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ImageArchive.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ImageArchive