ImageArchive/ImageArchive.py - diff

Return to ImageArchive.py CVS log

Up to [Repository] / ImageArchive

Diff for /ImageArchive/ImageArchive.py between versions 1.35 and 1.52

version 1.35, 2004/11/17 10:34:20	version 1.52, 2005/04/10 13:47:25
Line 1	Line 1
from OFS.Folder import Folder	from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem	from OFS.SimpleItem import SimpleItem
from Globals import Persistent	from Globals import Persistent,package_home
from Acquisition import Implicit	from Acquisition import Implicit
from Products.PageTemplates.PageTemplateFile import PageTemplateFile	from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate	from Products.PageTemplates.PageTemplate import PageTemplate
Line 12 import xml.dom.minidom	Line 12 import xml.dom.minidom
import operator	import operator
import tempfile	import tempfile
import shutil	import shutil
	from types import *
	import time

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

	manage_options=()



def splitPath(str):	def splitPath(str):
str2=str.replace("\\","/")	str2=str.replace("\\","/")
Line 26 def getText(nodelist):	Line 39 def getText(nodelist):
rc = rc + node.data	rc = rc + node.data
return rc	return rc

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

	class metaData(SimpleItem):
	"""Klasse fuer metadaten"""
	meta_type="metaData"

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


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

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

	md=dom.getElementsByTagName(container)
	mlist=[]
	if md:
	for node in md[0].childNodes:
	if node.nodeType==dom.ELEMENT_NODE:
	name=node.tagName
	content=getTextFromNode(node)
	setattr(self,name,content)
	mlist.append(name)
	self.mlist=mlist[0:]
	else:
	self.mlist=[]

	def index_html(self):
	"""index"""
	ret="<html><body>"
	for tag in self.mlist:
	ret+="<p>%s=%s</p>"%(tag,getattr(self,tag))
	return ret+"</body></html>"


class ImageDigilib(Folder,Persistent,Implicit):	class ImageDigilib(Folder,Persistent,Implicit):
"""Anzeige object fuer digilib"""	"""Anzeige object fuer digilib"""
Line 58 class ImageDigilib(Folder,Persistent,Imp	Line 117 class ImageDigilib(Folder,Persistent,Imp

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


Line 72 class ImageDigilib(Folder,Persistent,Imp	Line 131 class ImageDigilib(Folder,Persistent,Imp
"""ausgabe der metadaten"""	"""ausgabe der metadaten"""
return self.meta	return self.meta

	def manageMetaData(self,strict=None):
	"""create or updateMetadata"""

	md=self.ZopeFind(self,obj_metatypes=["metaData"])

	if not md:
	self._setObject("metaData",metaData(self.meta,"ROW"))

	else:
	if not strict:
	md[0][1].update(self.meta,"ROW")
	else:
	print "strict"
	if len(md[0][1].mlist)==0:
	print " +++",self.getId()
	md[0][1].update(self.meta,"ROW")
	else:
	print " ---",self.getId()

def uploadImage(self,fileupload,path_name):	def uploadImage(self,fileupload,path_name):
"""upload an Image from an Requast"""	"""upload an Image from an Requast"""
#path_name=self.ImageStoragePath	#path_name=self.ImageStoragePath
Line 82 class ImageDigilib(Folder,Persistent,Imp	Line 160 class ImageDigilib(Folder,Persistent,Imp
f.write(filedata)	f.write(filedata)
f.close()	f.close()
try:	try:
os.chmod(filename,0644)	os.chmod(filename,0664)
except:	except:
"""hack"""	"""hack"""
#scale thumb	#scale thumb
Line 94 class ImageDigilib(Folder,Persistent,Imp	Line 172 class ImageDigilib(Folder,Persistent,Imp
self.scaleWorkingVersions()	self.scaleWorkingVersions()



def downloadWorkingVersion(self):	def downloadWorkingVersion(self):
"""download working version (2000 pixel)"""	"""download working version (2000 pixel)"""

Line 113 class ImageDigilib(Folder,Persistent,Imp	Line 192 class ImageDigilib(Folder,Persistent,Imp

self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)	self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%filename)
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")	self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
image=urllib.urlopen(path).read()	#print path
self.REQUEST.RESPONSE.write(image)	imagefh=urllib.urlopen(path,'rb')

	self.REQUEST.RESPONSE.write(imagefh.read())
self.REQUEST.RESPONSE.close()	self.REQUEST.RESPONSE.close()
#return self.REQUEST.RESPONSE.redirect(path)	#return self.REQUEST.RESPONSE.redirect(path)

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

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

	def renameImage(self,newname,RESPONSE=None):
	"""umbenennen"""
	#umbennen des files im folder
	oldname=self.getId()
	self.aq_parent.manage_renameObjects(ids=[oldname],new_ids=[newname])
	self.title=newname[0:]
	self.filename=newname[0:]
	#umbennen des files auf dem server
	oldpath=os.path.join(self.ImageStoragePath,oldname)
	newpath=os.path.join(self.ImageStoragePath,newname)
	os.rename(oldpath,newpath)

	#umbenennen des versionsfolders
	oldfolder=os.path.join(self.ImageStoragePath,"."+oldname+".dir")
	newfolder=os.path.join(self.ImageStoragePath,"."+newname+".dir")
	if os.path.exists(oldfolder):
	os.rename(oldfolder,newfolder)
	else:
	os.mkdir(newfolder)

	#schreibe info uber umbennenung

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

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

	str="""%s %s %s %s\n"""%(tm,user,oldname,newname)
	fh.write(str)
	fh.close()

	#scale thumb

	self.scaleThumbs()

	#scale standard

	self.scaleWorkingVersions()


	if RESPONSE:
	RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)


	def updateImage(self,file,rename=None,RESPONSE=None):
	"""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")

	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 rename:
	self.renameImage(file.filename)


	if RESPONSE:
	RESPONSE.redirect(self.aq_parent.absolute_url()+"?filename="+self.filename)


	return "done"

	def thumb(self,url=None):
"""show thumb"""	"""show thumb"""
thumbname=os.path.splitext(self.filename)[0]+".jpg"	thumbname=os.path.splitext(self.filename)[0]+".jpg"
## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):	## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):
Line 133 class ImageDigilib(Folder,Persistent,Imp	Line 323 class ImageDigilib(Folder,Persistent,Imp
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="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	#path="/mpiwg/online/"+self.ImageViewerPath+"/"+thumbname
self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path	self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
pt=PageTemplateFile('Products/ImageArchive/zpt/thumb.zpt').__of__(self)	if url:
	return "<img border=\"0\" src=\"%s\">"% path
	else:
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumb.zpt')).__of__(self)
return pt()	return pt()

def index_html(self):	def index_html(self):
"""show image"""	"""show image"""
#DEVELOP: take first one for server	#DEVELOP: take first one for server

path="http://content.mpiwg-berlin.mpg.de/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+self.filename	path="http://content.mpiwg-berlin.mpg.de/zogilib_images?lv=2&fn="+self.ImageViewerPath+"/"+os.path.splitext(self.filename)[0]

#path="http://localhost:8080/mpiwg/online/"+self.ImageViewerPath+"/"+self.filename
#self.REQUEST.SESSION['string']="<img src=\"%s\">"% path
#pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)
return self.REQUEST.RESPONSE.redirect(path)	return self.REQUEST.RESPONSE.redirect(path)


def manage_AddImageDigilibForm(self):	def manage_AddImageDigilibForm(self):
"""Nothing yet"""	"""Nothing yet"""
pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageDigilibForm.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageDigilibForm.zpt')).__of__(self)
return pt()	return pt()

def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):	def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
"""Add ImageCollection"""	"""Add ImageCollection"""

#fileupload=self.REQUEST['fileupload']	#fileupload=self.REQUEST['fileupload']
fn=splitPath(fileupload.filename)	fn=splitPath(fileupload.filename)
newObj=ImageDigilib(id,fn,meta)	newObj=ImageDigilib(id,fn,meta)
Line 166 def manage_AddImageDigilib(self,id,fileu	Line 356 def manage_AddImageDigilib(self,id,fileu
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')


class ImageCollection(Folder, Persistent, Implicit):
	class ImageCollection(Folder, Persistent, Implicit,ECHO_basis):

"""Sammelordner f�r Bilder"""	"""Sammelordner f�r Bilder"""
meta_type="ImageCollection"	meta_type="ImageCollection"



genericMetaDataType="leiden_meta"	genericMetaDataType="leiden_meta"

leiden_meta_fields=['image_id','date','country','place','people','description','photographer']	leiden_meta_fields=['image_id','date','country','place','people','description','photographer']
Line 181 class ImageCollection(Folder, Persistent	Line 375 class ImageCollection(Folder, Persistent

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

tmpPath=tempfile.mktemp()	tmpPath=tempfile.mktemp()
Line 219 class ImageCollection(Folder, Persistent	Line 414 class ImageCollection(Folder, Persistent

if local:	if local:
if version=="working":	if version=="working":
sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+id[0]	sourcePath="/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+os.path.splitext(id[0])[0]+".jpg"
else:	else:
sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]	sourcePath="/mpiwg/online/"+self.ImageViewerPath+"/"+id[0]
targetPath=tmpPath+"/"+filename	targetPath=tmpPath+"/"+filename
Line 247 class ImageCollection(Folder, Persistent	Line 442 class ImageCollection(Folder, Persistent
#folgeseiten	#folgeseiten
if int(self.REQUEST.SESSION['filenamesIds'][id[0]][1])>1:	if int(self.REQUEST.SESSION['filenamesIds'][id[0]][1])>1:
ids=self.show_thumbs()	ids=self.show_thumbs()
	try:
nr=ids.index(id[0])	nr=ids.index(id[0])
	except:
	if RESPONSE:
	RESPONSE.write(str("<p>Error in File: %s (possible missing)<br>\n"%id[0]))
	else:
	"""nothing"""

	nr=0

numberOfPages=self.REQUEST.SESSION['filenamesIds'][id[0]][1]	numberOfPages=self.REQUEST.SESSION['filenamesIds'][id[0]][1]
for k in range(int(numberOfPages)-1):	for k in range(int(numberOfPages)-1):
Line 356 class ImageCollection(Folder, Persistent	Line 559 class ImageCollection(Folder, Persistent
self.ImageViewerPath=ImageViewerPath	self.ImageViewerPath=ImageViewerPath
self.defaultMetaString=defaultMetaString	self.defaultMetaString=defaultMetaString

manage_options = Folder.manage_options+(	optTMP= Folder.manage_options

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

def weightForm(self):
"""Weight"""
pt=PageTemplateFile('Products/ImageArchive/zpt/changeWeight.zpt').__of__(self)
return pt()

def changeWeight(self,weight,RESPONSE=None):
"""Change weight"""
self.weight=weight

if RESPONSE is not None:	def importMetaData(self,strict=None):
RESPONSE.redirect('manage_main')	"""import metadata, if strict ist not None then only metadata will be rebuild where metadata is empty"""

	for image in self.ZopeFind(self,obj_metatypes=["ImageDigilib"]):
	print image[1].getId()
	image[1].manageMetaData(strict)
	return "ok"


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

def importMeta(self,fileupload,tag):	def importMetaFile(self,fileupload,tag):
"""import"""	"""import"""
filedata=fileupload.read()	filedata=fileupload.read()
dom=xml.dom.minidom.parseString(filedata)	dom=xml.dom.minidom.parseString(filedata)
Line 471 class ImageCollection(Folder, Persistent	Line 674 class ImageCollection(Folder, Persistent

def meta_default(self,filename):	def meta_default(self,filename):
"""url der metadaten"""	"""url der metadaten"""
return self.defaultMetaString % filename	return self.defaultMetaString % urllib.quote(filename)

def getThumbAttribute(self,id,attr):	def getThumbAttribute(self,id,attr):
if hasattr(self,id):	if hasattr(self,id):
Line 492 class ImageCollection(Folder, Persistent	Line 695 class ImageCollection(Folder, Persistent

url=urllib.unquote(url)	url=urllib.unquote(url)
xmldoc=urllib.urlopen(url).read()	xmldoc=urllib.urlopen(url).read()
#print url	#return xmldoc
try:	try:
dom=xml.dom.minidom.parseString(xmldoc)	dom=xml.dom.minidom.parseString(xmldoc)
except:	except:
Line 503 class ImageCollection(Folder, Persistent	Line 706 class ImageCollection(Folder, Persistent
fnIds={}	fnIds={}
for image in images:	for image in images:
imagename=image.getElementsByTagName('imagename')[0]	imagename=image.getElementsByTagName('imagename')[0]
text=getText(imagename.childNodes)


idnr=image.getElementsByTagName('idnr')[0]	idnr=image.getElementsByTagName('idnr')[0]
id=getText(idnr.childNodes)	id=getText(idnr.childNodes)
numberOfPages=image.getElementsByTagName('numberOfPages')[0]	numberOfPages=image.getElementsByTagName('numberOfPages')[0]
Line 512 class ImageCollection(Folder, Persistent	Line 717 class ImageCollection(Folder, Persistent
nop=int(nopT)	nop=int(nopT)
except:	except:
nop=0	nop=0
	texts=getText(imagename.childNodes).split("\n") #mehrere bilder in return getrennter liste
	for text in texts:
if not text=="":	if not text=="":
	try:
rc.append((str(text),id,nop))	rc.append((str(text),id,nop))
fnIds[str(text)]=(id,nop)	fnIds[str(text)]=(id,nop)
	except:
	rc.append((repr(text),id,nop))
	fnIds[repr(text)]=(id,nop)


rc.sort()	rc.sort()
self.REQUEST.SESSION['filenames']=rc	self.REQUEST.SESSION['filenames']=rc
self.REQUEST.SESSION['filenamesIds']=fnIds	self.REQUEST.SESSION['filenamesIds']=fnIds

pt=PageTemplateFile('Products/ImageArchive/zpt/overview_selected.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected.zpt')).__of__(self)
return pt()	return pt()

def recalculateMeta(self):	def recalculateMetaLink(self):
"""recalculate the metadata"""	"""recalculate the metadata"""

for entryid in self.__dict__:	for entryid in self.__dict__:
Line 535 class ImageCollection(Folder, Persistent	Line 748 class ImageCollection(Folder, Persistent

def addImage(self):	def addImage(self):
"""Add an Image"""	"""Add an Image"""
pt=PageTemplateFile('Products/ImageArchive/zpt/addImage.zpt').__of__(self)
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addImage.zpt')).__of__(self)
return pt()	return pt()

def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):	def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):
"""Add"""	"""Add"""

#print "FU",fileupload	#print "FU",fileupload

if use_default:	if use_default:
Line 573 class ImageCollection(Folder, Persistent	Line 788 class ImageCollection(Folder, Persistent
#print newObj	#print newObj
self._setObject(file,newObj)	self._setObject(file,newObj)
#print ret	#print ret
#pt=PageTemplateFile('Products/ImageArchive/out.zpt').__of__(self)	#pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
#print self.ImageStoragePath	#print self.ImageStoragePath

#scale thumb	#scale thumb
Line 587 class ImageCollection(Folder, Persistent	Line 802 class ImageCollection(Folder, Persistent

RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')

	def importStructure(self,path):
	"""import"""
	splitted=os.path.split(path)
	if os.path.isDir(path):
	manage_AddImageCollection(self,splitted[1],splitted[1],path,self.ImageViewerPath,self.defaultMetaString,RESPONSE=None)

	obj=getattr(self,splitted[1])
	obj.ImportFiles()

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


	for file in files:

	if os.path.isdir(os.path.join(self.ImageStoragePath,file)):
	imageStoragePath=os.path.join(self.ImageStoragePath,file)
	imageViewerPath=os.path.join(self.ImageViewerPath,file)
	manage_AddImageCollection(self,file,file,imageStoragePath,imageViewerPath,self.defaultMetaString)

	obj=getattr(self,file)
	obj.ImportStructure()
	else:
	if not file[0]==".":
	if self.__dict__.has_key(file):

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

	#scale thumb

	#self.scaleThumbs()

	#scale standard

	#self.scaleWorkingVersions()

	if RESPONSE:
	RESPONSE.redirect('manage_main')

def ImportFiles(self,RESPONSE=None):	def ImportFiles(self,RESPONSE=None):
"""Import the existing files of a folder"""	"""Import the existing files of a folder"""
files=os.listdir(self.ImageStoragePath)	files=os.listdir(self.ImageStoragePath)
Line 607 class ImageCollection(Folder, Persistent	Line 876 class ImageCollection(Folder, Persistent
except:	except:
"""nothing yet"""	"""nothing yet"""
#print ret	#print ret
#pt=PageTemplateFile('Products/ImageArchive/out.zpt').__of__(self)	#pt=PageTemplateFile('Products/ImageArchive/out.zpt')).__of__(self)
#print self.ImageStoragePath	#print self.ImageStoragePath

#scale thumb	#scale thumb
Line 626 class ImageCollection(Folder, Persistent	Line 895 class ImageCollection(Folder, Persistent
if not hasattr(self,'defaultMetaString'):	if not hasattr(self,'defaultMetaString'):
self.defaultMetaString=""	self.defaultMetaString=""

pt=PageTemplateFile('Products/ImageArchive/zpt/ChangeImageCollectionForm.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeImageCollectionForm.zpt')).__of__(self)
return pt()	return pt()

def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):	def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
Line 641 class ImageCollection(Folder, Persistent	Line 910 class ImageCollection(Folder, Persistent

def show_selected_thumbs(self):	def show_selected_thumbs(self):
#ids=[]	#ids=[]
	try:
return self.REQUEST.SESSION['filenames']	return self.REQUEST.SESSION['filenames']
	except:
	return None
def show_thumbs(self):	def show_thumbs(self):
ids=[]	ids=[]
for entry in self.__dict__:	for entry in self.__dict__:
Line 741 class ImageCollection(Folder, Persistent	Line 1011 class ImageCollection(Folder, Persistent
return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"	return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
else:	else:
return ""	return ""
	def showFolders(self):
	"""show subfolders"""
	ret=""
	link=""" <a target="_top" href="%s">%s</a><br>"""

	if self.aq_parent.meta_type=="ImageCollection":
	ret+=link%(self.aq_parent.absolute_url(), "back ("+self.aq_parent.title+")")
	ret+="<br>"

	iCs=self.ZopeFind(self,obj_metatypes=["ImageCollection"])
	if not iCs:
	return ret
	else:

	link=""" <a target="_top" href="%s">%s</a><br>"""
	for iC in iCs:
	ret+=link%(iC[1].absolute_url(),iC[0])
	ret+="<br>"
	return ret
def showRuler(self,selected=None):	def showRuler(self,selected=None):
"""show ruler"""	"""show ruler"""
showall =self.REQUEST.SESSION.get('showall','no')	showall =self.REQUEST.SESSION.get('showall','no')
Line 750 class ImageCollection(Folder, Persistent	Line 1038 class ImageCollection(Folder, Persistent
return "<b>No entries</b>"	return "<b>No entries</b>"

if showall=='no':	if showall=='no':
	actualNr=0
ids=self.show_thumbs()	ids=self.show_thumbs()
colRows=self.getColTimesRow()	colRows=self.getColTimesRow()
num=int(len(ids)/(colRows[0]*colRows[1]))	num=int(len(ids)/(colRows[0]*colRows[1]))
Line 757 class ImageCollection(Folder, Persistent	Line 1046 class ImageCollection(Folder, Persistent
num+=1	num+=1
a=colRows[0]*colRows[1]	a=colRows[0]*colRows[1]
#print num,num+1	#print num,num+1

if num>1:	if num>1:

ret="<b>Show thumbnail group no:</b></br>"	ret=""
	if selected:
	ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""/selection?filename='+this.options[this.selectedIndex].value">"""
	else:
	ret+="""<select onChange="parent.location.href='"""+self.REQUEST['URL1']+"""?filename='+this.options[this.selectedIndex].value">"""
for i in range(num):	for i in range(num):
if (operator.mod(i,10)==0) and i>0:	try:
ret +="<br/>" #alle 10 linebreak einfuegen	nr=ids.index(self.REQUEST.SESSION['filename'])
	except:
	nr=0
k=i*a	k=i*a
	if (k <= nr) and (nr < i*(a+1)):
	actualNr=i
	ret+="""<option value="%s" selected>%i</option>"""%(ids[k],i)
	else:
	ret+="""<option value="%s">%i</option>"""%(ids[k],i)
	ret+="</select>"
	anf="<b>Show thumbnail group no:</b></br>"


	try:
if selected:	if selected:
href=self.REQUEST['URL1']+"/selection?filename="+ids[k]	href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr-1)*a]
else:	else:
href=self.REQUEST['URL1']+"?filename="+ids[int(k)]	href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr-1)*a)]

	anf+="""<a href="%s" target="_top">%s</a>  """%(href,"prev")
	except:
	pass
	ret=anf+ret

ret+="""<a href="%s" target="_top">%i</a>  """%(href,i)	try:

	if selected:
	href=self.REQUEST['URL1']+"/selection?filename="+ids[(actualNr+1)*a]
	else:
	href=self.REQUEST['URL1']+"?filename="+ids[int((actualNr+1)*a)]

	end="""<a href="%s" target="_top">%s</a>  """%(href,"next")
	except:
	end=""
	ret=ret+end


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

else:	else:
ret=""	ret=""
Line 782 class ImageCollection(Folder, Persistent	Line 1115 class ImageCollection(Folder, Persistent
def show_thumbs_selected_rows(self,numberOfColumns):	def show_thumbs_selected_rows(self,numberOfColumns):
"""Ausgabe anzahl"""	"""Ausgabe anzahl"""
ids=self.show_selected_thumbs()	ids=self.show_selected_thumbs()

	if not ids:
	return None
self.REQUEST.SESSION['ids']=ids	self.REQUEST.SESSION['ids']=ids
number=int(len(ids)/numberOfColumns)+1	number=int(len(ids)/numberOfColumns)+1
self.REQUEST.SESSION['number']=range(number)	self.REQUEST.SESSION['number']=range(number)
Line 789 class ImageCollection(Folder, Persistent	Line 1125 class ImageCollection(Folder, Persistent

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

def setDone(self):	def setDone(self):
"""done"""	"""done"""

pt=PageTemplateFile('Products/ImageArchive/zpt/changedColTimesRow.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changedColTimesRow.zpt')).__of__(self)
return pt()	return pt()

def setColTimesRow(self,cols,rows):	def setColTimesRow(self,cols,rows):
Line 852 class ImageCollection(Folder, Persistent	Line 1188 class ImageCollection(Folder, Persistent
return 0	return 0
if self.REQUEST.SESSION.has_key("filename"):	if self.REQUEST.SESSION.has_key("filename"):
filename=self.REQUEST.SESSION["filename"]	filename=self.REQUEST.SESSION["filename"]
	filename=self.getImageByName(filename,onlyName="yes")

try:	try:
startId=filename	startId=filename
Line 897 class ImageCollection(Folder, Persistent	Line 1233 class ImageCollection(Folder, Persistent

def thumblistSelected_old(self):	def thumblistSelected_old(self):
"""main template collection"""	"""main template collection"""
pt=PageTemplateFile('Products/ImageArchive/zpt/thumbselected.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbselected.zpt')).__of__(self)
return pt()	return pt()

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

def thumblist_old(self):	def thumblist_old(self):
"""main template collection"""	"""main template collection"""
pt=PageTemplateFile('Products/ImageArchive/zpt/thumbs.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)
return pt()	return pt()

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

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


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

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


Line 941 class ImageCollection(Folder, Persistent	Line 1278 class ImageCollection(Folder, Persistent
else:	else:
filen=""	filen=""
self.REQUEST.SESSION['filename']=filen	self.REQUEST.SESSION['filename']=filen
pt=PageTemplateFile('Products/ImageArchive/zpt/overview_selected2.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview_selected2.zpt')).__of__(self)
return pt()	return pt()

	def getImageByName(self,filename,onlyName=None):
	"""get filename"""

	fn=getattr(self,filename,None)
	if not fn:
	filenameM=filename.split(".")[0]
	founds=self.ZopeFind(self,obj_metatypes=['ImageDigilib'])
	for found in founds:
	foundM=found[0].split(".")[0]
	if filenameM.lower()==foundM.lower():
	if onlyName:
	return found[0]
	else:
	return found[1]
	if onlyName:
	return filename
	else:
	return fn
def index_html(self):	def index_html(self):
"""main template collection"""	"""main template collection"""
if self.REQUEST.has_key('filename'):	if self.REQUEST.has_key('filename'):
Line 951 class ImageCollection(Folder, Persistent	Line 1306 class ImageCollection(Folder, Persistent
else:	else:
filen=""	filen=""

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

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

Line 960 class ImageCollection(Folder, Persistent	Line 1315 class ImageCollection(Folder, Persistent
self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')	self.REQUEST.SESSION['showall']=self.REQUEST.SESSION.get('showall','no')


pt=PageTemplateFile('Products/ImageArchive/zpt/overview.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','overview.zpt')).__of__(self)
return pt()	return pt()

def manage_AddImageCollectionForm(self):	def manage_AddImageCollectionForm(self):
"""Nothing yet"""	"""Nothing yet"""
pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageCollectionForm.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionForm.zpt')).__of__(self)
return pt()	return pt()

def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):	def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
Line 1005 class ImageCollectionIFrame(ImageCollect	Line 1360 class ImageCollectionIFrame(ImageCollect
self.REQUEST.SESSION['filename']=filen	self.REQUEST.SESSION['filename']=filen


pt=PageTemplateFile('Products/ImageArchive/zpt/IFrameMain.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameMain.zpt')).__of__(self)
return pt()	return pt()

def iframe_html(self):	def iframe_html(self):
Line 1015 class ImageCollectionIFrame(ImageCollect	Line 1370 class ImageCollectionIFrame(ImageCollect
else:	else:
filen=""	filen=""
self.REQUEST.response.setCookie('filename',filen)	self.REQUEST.response.setCookie('filename',filen)
pt=PageTemplateFile('Products/ImageArchive/zpt/IFrameOverview.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','IFrameOverview.zpt')).__of__(self)
return pt()	return pt()


def manage_AddImageCollectionIFrameForm(self):	def manage_AddImageCollectionIFrameForm(self):
"""Nothing yet"""	"""Nothing yet"""
pt=PageTemplateFile('Products/ImageArchive/zpt/AddImageCollectionIFrameForm.zpt').__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddImageCollectionIFrameForm.zpt')).__of__(self)
return pt()	return pt()

def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):	def manage_AddImageCollectionIFrame(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):

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

Removed from v.1.35
changed lines
	Added in v.1.52