documentViewer/documentViewer.py - diff

Return to documentViewer.py CVS log

Up to [Repository] / documentViewer

Diff for /documentViewer/documentViewer.py between versions 1.6 and 1.29

version 1.6, 2006/04/10 11:23:18	version 1.29, 2007/06/15 14:16:27
Line 1	Line 1

genericDigilib="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/"

from OFS.Folder import Folder	from OFS.Folder import Folder
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate	from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Products.PageTemplates.PageTemplateFile import PageTemplateFile	from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from AccessControl import ClassSecurityInfo	from AccessControl import ClassSecurityInfo
	from AccessControl import getSecurityManager
from Globals import package_home	from Globals import package_home

from Ft.Xml.Domlette import NonvalidatingReader	from Ft.Xml.Domlette import NonvalidatingReader
from Ft.Xml.Domlette import PrettyPrint, Print	from Ft.Xml.Domlette import PrettyPrint, Print
from Ft.Xml import EMPTY_NAMESPACE	from Ft.Xml import EMPTY_NAMESPACE, Parse

import Ft.Xml.XPath	import Ft.Xml.XPath

import os.path	import os.path
	import sys
import cgi	import cgi
import urllib	import urllib
import zLOG	import logging
	import math

	import urlparse

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


def getInt(number, default=0):	def getInt(number, default=0):
"""returns always an int (0 in case of problems)"""	"""returns always an int (0 in case of problems)"""
try:	try:
return int(number)	return int(number)
except:	except:
return default	return int(default)


def getTextFromNode(nodename):	def getTextFromNode(nodename):
	"""get the cdata content of a node"""
	if nodename is None:
	return ""
nodelist=nodename.childNodes	nodelist=nodename.childNodes
rc = ""	rc = ""
for node in nodelist:	for node in nodelist:
Line 34 def getTextFromNode(nodename):	Line 45 def getTextFromNode(nodename):
rc = rc + node.data	rc = rc + node.data
return rc	return rc


	def getParentDir(path):
	"""returns pathname shortened by one"""
	return '/'.join(path.split('/')[0:-1])


import socket	import socket

def urlopen(url):	def urlopen(url,timeout=2):
"""urlopen mit timeout"""	"""urlopen mit timeout"""
socket.setdefaulttimeout(2)	socket.setdefaulttimeout(timeout)
ret=urllib.urlopen(url)	ret=urllib.urlopen(url)
socket.setdefaulttimeout(5)	socket.setdefaulttimeout(5)
return ret	return ret




##	##
## documentViewer class	## documentViewer class
##	##
class documentViewer(Folder):	class documentViewer(Folder):
"""document viewer"""	"""document viewer"""
	#textViewerUrl="http://127.0.0.1:8080/HFQP/testXSLT/getPage?"

meta_type="Document viewer"	meta_type="Document viewer"

Line 65 class documentViewer(Folder):	Line 81 class documentViewer(Folder):
image_main = PageTemplateFile('zpt/image_main', globals())	image_main = PageTemplateFile('zpt/image_main', globals())
head_main = PageTemplateFile('zpt/head_main', globals())	head_main = PageTemplateFile('zpt/head_main', globals())
docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())	docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())
	info_xml = PageTemplateFile('zpt/info_xml', globals())

security.declareProtected('View management screens','changeDocumentViewerForm')	security.declareProtected('View management screens','changeDocumentViewerForm')
changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())	changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())


def __init__(self,id,imageViewerUrl,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=10):	def __init__(self,id,imageViewerUrl,textViewerUrl=None,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=10,authgroups="mpiwg"):
"""init document viewer"""	"""init document viewer"""
self.id=id	self.id=id
self.title=title	self.title=title
self.imageViewerUrl=imageViewerUrl	self.imageViewerUrl=imageViewerUrl
	self.textViewerUrl=textViewerUrl

if not digilibBaseUrl:	if not digilibBaseUrl:
self.digilibBaseUrl = self.findDigilibUrl()	self.digilibBaseUrl = self.findDigilibUrl()
else:	else:
self.digilibBaseUrl = digilibBaseUrl	self.digilibBaseUrl = digilibBaseUrl
self.thumbcols = thumbcols	self.thumbcols = thumbcols
self.thumbrows = thumbrows	self.thumbrows = thumbrows
	# authgroups is list of authorized groups (delimited by ,)
	self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
# add template folder so we can always use template.something	# add template folder so we can always use template.something
self.manage_addFolder('template')	self.manage_addFolder('template')


security.declareProtected('View','index_html')	security.declareProtected('View','index_html')
def index_html(self,mode,url,start=None,pn=1):	def index_html(self,mode,url,viewMode="auto",start=None,pn=1):
'''	'''
view it	view it
@param mode: defines which type of document is behind url	@param mode: defines how to access the document behind url
@param url: url which contains display information	@param url: url which contains display information
	@param viewMode: if images display images, if text display text, default is images (text,images or auto)

'''	'''

zLOG.LOG("documentViewer (index)", zLOG.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))	logger("documentViewer (index)", logging.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))

if not hasattr(self, 'template'):	if not hasattr(self, 'template'):
# create template folder if it doesn't exist	# create template folder if it doesn't exist
print "no template folder -- creating"
self.manage_addFolder('template')	self.manage_addFolder('template')

if not self.digilibBaseUrl:	if not self.digilibBaseUrl:
Line 106 class documentViewer(Folder):	Line 128 class documentViewer(Folder):
docinfo = self.getDocinfo(mode=mode,url=url)	docinfo = self.getDocinfo(mode=mode,url=url)
pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)	pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
pt = getattr(self.template, 'viewer_main')	pt = getattr(self.template, 'viewer_main')
return pt(docinfo=docinfo,pageinfo=pageinfo)
	if viewMode=="auto": # automodus gewaehlt
	if docinfo.get("textURL",'') and self.textViewerUrl: #texturl gesetzt und textViewer konfiguriert
	viewMode="text"
	else:
	viewMode="images"

	return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode)


def getLink(self,param=None,val=None):	def getLink(self,param=None,val=None):
"""link to documentviewer with parameter param set to val"""	"""link to documentviewer with parameter param set to val"""
params=cgi.parse_qs(self.REQUEST['QUERY_STRING'])	params=self.REQUEST.form.copy()
if param is not None:	if param is not None:
if val is None and params.has_key(param):	if val is None:
	if params.has_key(param):
del params[param]	del params[param]
else:	else:
params[param] = val	params[param] = str(val)

url=self.REQUEST['URL']+"?"+urllib.urlencode(params, doseq=True)	# quote values and assemble into query string
	ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()])
	url=self.REQUEST['URL1']+"?"+ps
return url	return url


	def getInfo_xml(self,url,mode):
	"""returns info about the document as XML"""

	if not self.digilibBaseUrl:
	self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"

	docinfo = self.getDocinfo(mode=mode,url=url)
	pt = getattr(self.template, 'info_xml')
	return pt(docinfo=docinfo)


def getStyle(self, idx, selected, style=""):	def getStyle(self, idx, selected, style=""):
"""returns a string with the given style and append 'sel' if path == selected."""	"""returns a string with the given style and append 'sel' if path == selected."""
#zLOG.LOG("documentViewer (getstyle)", zLOG.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))	#logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
if idx == selected:	if idx == selected:
return style + 'sel'	return style + 'sel'
else:	else:
return style	return style


def getParamFromDigilib(self,path,param):	def isAccessible(self, docinfo):
	"""returns if access to the resource is granted"""
	access = docinfo.get('accessType', None)
	logger("documentViewer (accessOK)", logging.INFO, "access type %s"%access)
	if access is not None and access == 'free':
	logger("documentViewer (accessOK)", logging.INFO, "access is free")
	return True
	elif access is None or access in self.authgroups:
	# only local access -- only logged in users
	user = getSecurityManager().getUser()
	if user is not None:
	#print "user: ", user
	return (user.getUserName() != "Anonymous User")
	else:
	return False

	logger("documentViewer (accessOK)", logging.INFO, "unknown access type %s"%access)
	return False


	def getDirinfoFromDigilib(self,path,docinfo=None):
"""gibt param von dlInfo aus"""	"""gibt param von dlInfo aus"""
imageUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path	num_retries = 3
	if docinfo is None:
	docinfo = {}

	infoUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path

zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo (%s) from %s"%(param,imageUrl))	logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo from %s"%(infoUrl))

	for cnt in range(num_retries):
try:	try:
dom = NonvalidatingReader.parseUri(imageUrl)	# dom = NonvalidatingReader.parseUri(imageUrl)
	txt=urllib.urlopen(infoUrl).read()
	dom = Parse(txt)
	break
except:	except:
return None	logger("documentViewer (getdirinfofromdigilib)", logging.ERROR, "error reading %s (try %d)"%(infoUrl,cnt))
	else:
	raise IOError("Unable to get dir-info from %s"%(infoUrl))

params=dom.xpath("//dir/%s"%param)	sizes=dom.xpath("//dir/size")
zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo:%s"%params)	logger("documentViewer (getparamfromdigilib)", logging.INFO, "dirInfo:size"%sizes)

if params:	if sizes:
return getTextFromNode(params[0])	docinfo['numPages'] = int(getTextFromNode(sizes[0]))
	else:
	docinfo['numPages'] = 0

	return docinfo

def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None):
"""gets bibliographical info from the index.meta file at url or given by dom"""
zLOG.LOG("documentViewer (getbibinfofromindexmeta)", zLOG.INFO,"path: %s"%(path))

if docinfo is None:	def getIndexMeta(self, url):
docinfo = {}	"""returns dom of index.meta document at url"""
	num_retries = 3
	dom = None
	metaUrl = None
	if url.startswith("http://"):
	# real URL
	metaUrl = url
	else:
	# online path
	server=self.digilibBaseUrl+"/servlet/Texter?fn="
	metaUrl=server+url.replace("/mpiwg/online","")
	if not metaUrl.endswith("index.meta"):
	metaUrl += "/index.meta"
	print metaUrl
	for cnt in range(num_retries):
	try:
	# patch dirk encoding fehler treten dann nicht mehr auf
	# dom = NonvalidatingReader.parseUri(metaUrl)
	txt=urllib.urlopen(metaUrl).read()
	dom = Parse(txt)
	break
	except:
	logger("ERROR documentViewer (getIndexMata)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])

if dom is None:	if dom is None:
server="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn="	raise IOError("Unable to read index meta from %s"%(url))
path="/".join(path.split("/")[0:-1])
metaUrl=server+path+"/index.meta"	return dom

	def getPresentationInfoXML(self, url):
	"""returns dom of info.xml document at url"""
	num_retries = 3
	dom = None
	metaUrl = None
	if url.startswith("http://"):
	# real URL
	metaUrl = url
	else:
	# online path
	server=self.digilibBaseUrl+"/servlet/Texter?fn="
	metaUrl=server+url.replace("/mpiwg/online","")


	for cnt in range(num_retries):
try:	try:
dom = NonvalidatingReader.parseUri(metaUrl)	# patch dirk encoding fehler treten dann nicht mehr auf
	# dom = NonvalidatingReader.parseUri(metaUrl)
	txt=urllib.urlopen(metaUrl).read()
	dom = Parse(txt)
	break
except:	except:
	logger("ERROR documentViewer (getPresentationInfoXML)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])

	if dom is None:
	raise IOError("Unable to read infoXMLfrom %s"%(url))

	return dom


	def getAuthinfoFromIndexMeta(self,path,docinfo=None,dom=None):
	"""gets authorization info from the index.meta file at path or given by dom"""
	logger("documentViewer (getauthinfofromindexmeta)", logging.INFO,"path: %s"%(path))

	access = None

	if docinfo is None:
	docinfo = {}

	if dom is None:
	dom = self.getIndexMeta(getParentDir(path))

	acctype = dom.xpath("//access-conditions/access/@type")
	if acctype and (len(acctype)>0):
	access=acctype[0].value
	if access in ['group', 'institution']:
	access = getTextFromNode(dom.xpath("//access-conditions/access/name")[0]).lower()

	docinfo['accessType'] = access
return docinfo	return docinfo


	def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None):
	"""gets bibliographical info from the index.meta file at path or given by dom"""
	logging.debug("documentViewer (getbibinfofromindexmeta) path: %s"%(path))

	if docinfo is None:
	docinfo = {}

	if dom is None:
	dom = self.getIndexMeta(getParentDir(path))

	# put in all raw bib fields as dict "bib"
	bib = dom.xpath("//bib/*")
	if bib and len(bib)>0:
	bibinfo = {}
	for e in bib:
	bibinfo[e.localName] = getTextFromNode(e)
	docinfo['bib'] = bibinfo

	# extract some fields (author, title, year) according to their mapping
metaData=self.metadata.main.meta.bib	metaData=self.metadata.main.meta.bib
bibtype=dom.xpath("//bib/@type")	bibtype=dom.xpath("//bib/@type")
if bibtype and (len(bibtype)>0):	if bibtype and (len(bibtype)>0):
bibtype=bibtype[0].value	bibtype=bibtype[0].value
else:	else:
bibtype="generic"	bibtype="generic"

bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC)	bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC)
	docinfo['bib_type'] = bibtype
bibmap=metaData.generateMappingForType(bibtype)	bibmap=metaData.generateMappingForType(bibtype)
if len(bibmap) > 0:	# if there is no mapping bibmap is empty (mapping sometimes has empty fields)
	if len(bibmap) > 0 and len(bibmap['author'][0]) > 0:
docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['author'][0])[0])	docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['author'][0])[0])
docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['title'][0])[0])	docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['title'][0])[0])
docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['year'][0])[0])	docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['year'][0])[0])
	logging.debug("documentViewer (getbibinfofromindexmeta) using mapping for %s"%bibtype)
	try:
	docinfo['lang']=getTextFromNode(dom.xpath("//bib/lang")[0])
	except:
	docinfo['lang']=''

return docinfo	return docinfo


def getDocinfoFromTextTool(self,url,docinfo=None):	def getDocinfoFromTextTool(self,url,dom=None,docinfo=None):
"""parse texttool tag in index meta"""	"""parse texttool tag in index meta"""
zLOG.LOG("documentViewer (getdocinfofromtexttool)", zLOG.INFO,"url: %s"%(url))	logger("documentViewer (getdocinfofromtexttool)", logging.INFO,"url: %s"%(url))
if docinfo is None:	if docinfo is None:
docinfo = {}	docinfo = {}

try:	if docinfo.get('lang',None) is None:
dom = NonvalidatingReader.parseUri(url)	docinfo['lang']='' # default keine Sprache gesetzt
except:	if dom is None:
zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])	dom = self.getIndexMeta(url)
return docinfo

archivePaths=dom.xpath("//resource/archive-path")	archivePath = None
	archiveName = None

	archiveNames=dom.xpath("//resource/name")
	if archiveNames and (len(archiveNames)>0):
	archiveName=getTextFromNode(archiveNames[0])
	else:
	logger("documentViewer (getdocinfofromtexttool)", logging.WARNING,"resource/name missing in: %s"%(url))

	archivePaths=dom.xpath("//resource/archive-path")
if archivePaths and (len(archivePaths)>0):	if archivePaths and (len(archivePaths)>0):
archivePath=getTextFromNode(archivePaths[0])	archivePath=getTextFromNode(archivePaths[0])
	# clean up archive path
	if archivePath[0] != '/':
	archivePath = '/' + archivePath
	if archiveName and (not archivePath.endswith(archiveName)):
	archivePath += "/" + archiveName
else:	else:
archivePath=None	# try to get archive-path from url
	logger("documentViewer (getdocinfofromtexttool)", logging.WARNING,"resource/archive-path missing in: %s"%(url))
images=dom.xpath("//texttool/image")	if (not url.startswith('http')):
	archivePath = url.replace('index.meta', '')
if images and (len(images)>0):
image=getTextFromNode(images[0])	if archivePath is None:
	# we balk without archive-path
	raise IOError("Missing archive-path (for text-tool) in %s"%(url))

	imageDirs=dom.xpath("//texttool/image")
	if imageDirs and (len(imageDirs)>0):
	imageDir=getTextFromNode(imageDirs[0])
else:	else:
image=None	# we balk with no image tag / not necessary anymore because textmode is now standard
	#raise IOError("No text-tool info in %s"%(url))
if image and archivePath:	imageDir=""
image=os.path.join(archivePath,image)	docinfo['numPages']=1 # im moment einfach auf eins setzen, navigation ueber die thumbs geht natuerlich nicht
image=image.replace("/mpiwg/online",'')
pt=self.getParamFromDigilib(image,'size')	docinfo['imagePath'] = "" # keine Bilder
docinfo['imagePath'] = image	docinfo['imageURL'] = ""
docinfo['numPages'] = pt
	if imageDir and archivePath:
	#print "image: ", imageDir, " archivepath: ", archivePath
	imageDir=os.path.join(archivePath,imageDir)
	imageDir=imageDir.replace("/mpiwg/online",'')
	docinfo=self.getDirinfoFromDigilib(imageDir,docinfo=docinfo)
	docinfo['imagePath'] = imageDir
	docinfo['imageURL'] = self.digilibBaseUrl+"/servlet/Scaler?fn="+imageDir

viewerUrls=dom.xpath("//texttool/digiliburlprefix")	viewerUrls=dom.xpath("//texttool/digiliburlprefix")

if viewerUrls and (len(viewerUrls)>0):	if viewerUrls and (len(viewerUrls)>0):
viewerUrl=getTextFromNode(viewerUrls[0])	viewerUrl=getTextFromNode(viewerUrls[0])
docinfo['imageURL'] = viewerURL	docinfo['viewerURL'] = viewerUrl

textUrls=dom.xpath("//texttool/text")	textUrls=dom.xpath("//texttool/text")

if textUrls and (len(textUrls)>0):	if textUrls and (len(textUrls)>0):
textUrl=getTextFromNode(textUrls[0])	textUrl=getTextFromNode(textUrls[0])
docinfo['textURL'] = textURL	if urlparse.urlparse(textUrl)[0]=="": #keine url
	textUrl=os.path.join(archivePath,textUrl)

docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom)	docinfo['textURL'] = textUrl

	presentationUrls=dom.xpath("//texttool/presentation")
	docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom) # get info von bib tag

	if presentationUrls and (len(presentationUrls)>0): # ueberschreibe diese durch presentation informationen
	# presentation url ergiebt sich ersetzen von index.meta in der url der f�r die Metadaten
	# durch den relativen Pfad auf die presentation infos
	presentationUrl=url.replace('index.meta',getTextFromNode(presentationUrls[0]))
	docinfo = self.getBibinfoFromTextToolPresentation(presentationUrl,docinfo=docinfo,dom=dom)

	docinfo = self.getAuthinfoFromIndexMeta(url,docinfo=docinfo,dom=dom) # get access info
return docinfo	return docinfo


	def getBibinfoFromTextToolPresentation(self,url,docinfo=None,dom=None):
	"""gets the bibliographical information from the preseantion entry in texttools
	"""
	dom=self.getPresentationInfoXML(url)
	try:
	docinfo['author']=getTextFromNode(dom.xpath("//author")[0])
	except:
	pass
	try:
	docinfo['title']=getTextFromNode(dom.xpath("//title")[0])
	except:
	pass
	try:
	docinfo['year']=getTextFromNode(dom.xpath("//date")[0])
	except:
	pass
	return docinfo

def getDocinfoFromImagePath(self,path,docinfo=None):	def getDocinfoFromImagePath(self,path,docinfo=None):
"""path ist the path to the images it assumes that the index.meta file is one level higher."""	"""path ist the path to the images it assumes that the index.meta file is one level higher."""
zLOG.LOG("documentViewer (getdocinfofromimagepath)", zLOG.INFO,"path: %s"%(path))	logger("documentViewer (getdocinfofromimagepath)", logging.INFO,"path: %s"%(path))
if docinfo is None:	if docinfo is None:
docinfo = {}	docinfo = {}
path=path.replace("/mpiwg/online","")	path=path.replace("/mpiwg/online","")
docinfo['imagePath'] = path	docinfo['imagePath'] = path
pt=self.getParamFromDigilib(path,'size')	docinfo=self.getDirinfoFromDigilib(path,docinfo=docinfo)
docinfo['numPages'] = pt	imageUrl=self.digilibBaseUrl+"/servlet/Scaler?fn="+path
imageUrl=self.digilibBaseUrl+"/servlet/Scaler?fn=%s"%path
docinfo['imageURL'] = imageUrl	docinfo['imageURL'] = imageUrl

docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo)	docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo)
	docinfo = self.getAuthinfoFromIndexMeta(path,docinfo=docinfo)
return docinfo	return docinfo


def getDocinfo(self, mode, url):	def getDocinfo(self, mode, url):
"""returns docinfo depending on mode"""	"""returns docinfo depending on mode"""
zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"mode: %s, url: %s"%(mode,url))	logger("documentViewer (getdocinfo)", logging.INFO,"mode: %s, url: %s"%(mode,url))
# look for cached docinfo in session	# look for cached docinfo in session
if self.REQUEST.SESSION.has_key('docinfo'):	if self.REQUEST.SESSION.has_key('docinfo'):
docinfo = self.REQUEST.SESSION['docinfo']	docinfo = self.REQUEST.SESSION['docinfo']
# check if its still current	# check if its still current
if docinfo is not None and docinfo.get('mode') == mode and docinfo.get('url') == url:	if docinfo is not None and docinfo.get('mode') == mode and docinfo.get('url') == url:
zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo in session: %s"%docinfo)	logger("documentViewer (getdocinfo)", logging.INFO,"docinfo in session: %s"%docinfo)
return docinfo	return docinfo
# new docinfo	# new docinfo
docinfo = {'mode': mode, 'url': url}	docinfo = {'mode': mode, 'url': url}
Line 263 class documentViewer(Folder):	Line 486 class documentViewer(Folder):
elif mode=="imagepath":	elif mode=="imagepath":
docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)	docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)
else:	else:
zLOG.LOG("documentViewer (getdocinfo)", zLOG.ERROR,"unknown mode!")	logger("documentViewer (getdocinfo)", logging.ERROR,"unknown mode!")
zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo: %s"%docinfo)	raise ValueError("Unknown mode %s"%(mode))

	logger("documentViewer (getdocinfo)", logging.INFO,"docinfo: %s"%docinfo)
self.REQUEST.SESSION['docinfo'] = docinfo	self.REQUEST.SESSION['docinfo'] = docinfo
return docinfo	return docinfo

Line 280 class documentViewer(Folder):	Line 505 class documentViewer(Folder):
pageinfo['cols'] = cols	pageinfo['cols'] = cols
grpsize = cols * rows	grpsize = cols * rows
pageinfo['groupsize'] = grpsize	pageinfo['groupsize'] = grpsize
start = getInt(start, default=(int(current / grpsize) * grpsize +1))	start = getInt(start, default=(math.ceil(float(current)/float(grpsize))*grpsize-(grpsize-1)))
print "start3:", start	# int(current / grpsize) * grpsize +1))
pageinfo['start'] = start	pageinfo['start'] = start
pageinfo['end'] = start + grpsize	pageinfo['end'] = start + grpsize
if docinfo is not None:	if docinfo is not None:
Line 298 class documentViewer(Folder):	Line 523 class documentViewer(Folder):
if mode=="texttool": #index.meta with texttool information	if mode=="texttool": #index.meta with texttool information
(viewerUrl,imagepath,textpath)=parseUrlTextTool(url)	(viewerUrl,imagepath,textpath)=parseUrlTextTool(url)

print textpath	#print textpath
try:	try:
dom = NonvalidatingReader.parseUri(textpath)	dom = NonvalidatingReader.parseUri(textpath)
except:	except:
Line 350 class documentViewer(Folder):	Line 575 class documentViewer(Folder):
def findDigilibUrl(self):	def findDigilibUrl(self):
"""try to get the digilib URL from zogilib"""	"""try to get the digilib URL from zogilib"""
url = self.imageViewerUrl[:-1] + "/getScalerUrl"	url = self.imageViewerUrl[:-1] + "/getScalerUrl"
	#print urlparse.urlparse(url)[0]
	#print urlparse.urljoin(self.absolute_url(),url)
	logging.info("finddigiliburl: %s"%urlparse.urlparse(url)[0])
	logging.info("finddigiliburl: %s"%urlparse.urljoin(self.absolute_url(),url))

try:	try:
	if urlparse.urlparse(url)[0]=='': #relative path
	url=urlparse.urljoin(self.absolute_url()+"/",url)

scaler = urlopen(url).read()	scaler = urlopen(url).read()
return scaler.replace("/servlet/Scaler?", "")	return scaler.replace("/servlet/Scaler?", "")
except:	except:
return None	return None

def changeDocumentViewer(self,imageViewerUrl,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=10,RESPONSE=None):	def changeDocumentViewer(self,imageViewerUrl,textViewerUrl,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=10,authgroups='mpiwg',RESPONSE=None):
"""init document viewer"""	"""init document viewer"""
self.title=title	self.title=title
self.imageViewerUrl=imageViewerUrl	self.imageViewerUrl=imageViewerUrl
	self.textViewerUrl=textViewerUrl
self.digilibBaseUrl = digilibBaseUrl	self.digilibBaseUrl = digilibBaseUrl
self.thumbrows = thumbrows	self.thumbrows = thumbrows
self.thumbcols = thumbcols	self.thumbcols = thumbcols
	self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')

Line 377 def manage_AddDocumentViewerForm(self):	Line 611 def manage_AddDocumentViewerForm(self):
pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)	pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
return pt()	return pt()

def manage_AddDocumentViewer(self,id,imageViewerUrl="",title="",RESPONSE=None):	def manage_AddDocumentViewer(self,id,imageViewerUrl="",textViewerUrl="",title="",RESPONSE=None):
"""add the viewer"""	"""add the viewer"""
newObj=documentViewer(id,imageViewerUrl,title)	newObj=documentViewer(id,imageViewerUrl,title=title,textViewerUrl=textViewerUrl)
self._setObject(id,newObj)	self._setObject(id,newObj)

if RESPONSE is not None:	if RESPONSE is not None:
Line 405 def manage_addDocumentViewerTemplate(sel	Line 639 def manage_addDocumentViewerTemplate(sel

self._setObject(id, DocumentViewerTemplate(id))	self._setObject(id, DocumentViewerTemplate(id))
ob = getattr(self, id)	ob = getattr(self, id)
ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/viewer_main.zpt')).read(),None)	txt=file(os.path.join(package_home(globals()),'zpt/viewer_main.zpt'),'r').read()
	logging.info("txt %s:"%txt)
	ob.pt_edit(txt,"text/html")
if title:	if title:
ob.pt_setTitle(title)	ob.pt_setTitle(title)
try:	try:

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

Removed from v.1.6
changed lines
	Added in v.1.29