zogiLib/zogiLib.py - diff

Return to zogiLib.py CVS log

Up to [Repository] / zogiLib

Diff for /zogiLib/zogiLib.py between versions 1.23 and 1.30

version 1.23, 2004/06/04 12:28:12	version 1.30, 2004/06/25 16:59:45
Line 12 import os	Line 12 import os
import re	import re
import string	import string
import urllib	import urllib
	import types
from Globals import package_home	from Globals import package_home

def getString(self,key,default=''):	ZOGIVERSION = "0.9.5 ROC:25.6.2004"
try:
return self.REQUEST[key]	def cropf(f):
except:	"""returns a float with reduced precision"""
return default	return float(int(f * 10000)/10000.0)


def sendFile(self, filename, type):	def sendFile(self, filename, type):
"""sends an object or a local file (in the product) as response"""	"""sends an object or a local file (in the product) as response"""
Line 41 def sendFile(self, filename, type):	Line 43 def sendFile(self, filename, type):
self.REQUEST.RESPONSE.write(file(fn).read())	self.REQUEST.RESPONSE.write(file(fn).read())
return	return

class BrowserCheck:	def browserCheck(self):
"""check the browsers request to find out the browser type"""	"""check the browsers request to find out the browser type"""
	bt = {}
def __init__(self, zope):	ua = self.REQUEST.get_header("HTTP_USER_AGENT")
self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")	bt['ua'] = ua
self.isIE = string.find(self.ua, 'MSIE') > -1	bt['isIE'] = string.find(ua, 'MSIE') > -1
self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and not self.isIE	bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1) and not bt['isIE']
self.nav = self.ua[string.find(self.ua, '('):]	nav = ua[string.find(ua, '('):]
ie = string.split(self.nav, "; ")[1]	ie = string.split(nav, "; ")[1]
if string.find(ie, "MSIE") > -1:	if string.find(ie, "MSIE") > -1:
self.versIE = string.split(ie, " ")[1]	bt['versIE'] = string.split(ie, " ")[1]
self.isMac = string.find(self.ua, 'Macintosh') > -1	bt['isMac'] = string.find(ua, 'Macintosh') > -1
self.isWin = string.find(self.ua, 'Windows') > -1	bt['isWin'] = string.find(ua, 'Windows') > -1
self.isIEWin = self.isIE and self.isWin	bt['isIEWin'] = bt['isIE'] and bt['isWin']
self.isIEMac = self.isIE and self.isMac	bt['isIEMac'] = bt['isIE'] and bt['isMac']
	bt['staticHTML'] = False

def manage_addZogiLibMainTemplateForm(self):
"""Form for adding"""
#FIXME:???
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/AddOSAS_thumbTemplate.zpt')).__of__(self)
return pt()




def manage_addZogiLibMainTemplate(self, id,title=None, text=None,	return bt
REQUEST=None, submit=None):
"Add a Page Template with optional file content."
#FIXME:???
id = str(id)
if REQUEST is None:
self._setObject(id, zogiLib_mainTemplate(id, text))
ob = getattr(self, id)

if title:
ob.pt_setTitle(title)
return ob
else:
file = REQUEST.form.get('file')
headers = getattr(file, 'headers', None)
if headers is None or not file.filename:
zpt = zogiLib_mainTemplate(id)
else:
zpt = zogiLib_mainTemplate(id, file, headers.get('content_type'))

self._setObject(id, zpt)
ob = getattr(self, id)


try:
u = self.DestinationURL()
except AttributeError:
u = REQUEST['URL1']

if submit == " Add and Edit ":
u = "%s/%s" % (u, quote(id))
REQUEST.RESPONSE.redirect(u+'/manage_main')
return ''


class zogiImage(Image):	class zogiImage(Image):
Line 427 class zogiLib(Folder):	Line 388 class zogiLib(Folder):
{'label':'Main Config','action':'changeZogiLibForm'},	{'label':'Main Config','action':'changeZogiLibForm'},
)	)

def __init__(self, id, title, digilibBaseUrl, localFileBase, version="book", basePath=""):	def __init__(self, id, title, digilibBaseUrl, localFileBase, version="book", basePath="", dlTarget=None):
"""init"""	"""init"""

self.id=id	self.id=id
Line 436 class zogiLib(Folder):	Line 397 class zogiLib(Folder):
self.localFileBase=localFileBase	self.localFileBase=localFileBase
self.basePath=basePath	self.basePath=basePath
self.layout=version	self.layout=version
	if dlTarget:
	self.dlTarget = dlTarget
	else:
	self.dlTarget = "digilib"

	def version(self):
	"""version information"""
	return ZOGIVERSION

def getDLInfo(self):	def getDLInfo(self):
"""get DLInfo from digilib server"""	"""get DLInfo from digilib server"""
Line 455 class zogiLib(Folder):	Line 423 class zogiLib(Folder):

def createHeadJS(self):	def createHeadJS(self):
"""generate all javascript tags for head"""	"""generate all javascript tags for head"""
	self.checkQuery()
	bt = self.REQUEST.SESSION['browserType']
	if bt['staticHTML']:
	return

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

def createParamJS(self):	def createParamJS(self):
"""generate javascript for parameters only"""	"""generate javascript for parameters only"""
	self.checkQuery()
	bt = self.REQUEST.SESSION['browserType']
	if bt['staticHTML']:
	return

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


def createScalerImg(self, requestString = None, bottom = 0, side = 0):	def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
"""generate Scaler IMG Tag"""	"""generate Scaler IMG Tag"""
self.checkQuery()	self.checkQuery()
bt = self.REQUEST.SESSION['browserType']	bt = self.REQUEST.SESSION['browserType']
	# override with parameters from session
	if self.REQUEST.SESSION.has_key('scalerDiv'):
	(requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']
	# if not explicitly defined take normal request
if not requestString:	if not requestString:
requestString = self.getAllDLParams()	requestString = self.getAllDLParams()
url = self.digilibBaseUrl+requestString	url = self.digilibBaseUrl+requestString
	# construct bottom and side insets
	b_par = ""
	s_par = ""
	if (bottom != 0) or (side != 0):
	b_par = "-" + str(int(bottom))
	s_par = "-" + str(int(side))
tag = ""	tag = ""
if bt.isN4:	if bt['staticHTML']:
	tag += '<div id="scaler"><img id="pic" src="%s&dw=%i&dh=%i" /></div>'%(url, int(width-side), int(height-bottom))
	else:
	if bt['isN4']:
	# N4 needs layers
tag += '<ilayer id="scaler">'	tag += '<ilayer id="scaler">'
else:	else:
tag += '<div id="scaler">'	tag += '<div id="scaler">'
tag += '<script type="text/javascript">'	tag += '<script type="text/javascript">'
tag += "var ps = bestPicSize(getElement('scaler'));"	tag += "var ps = bestPicSize(getElement('scaler'));"
b_par = ""	# write img tag with javascript
s_par = ""	tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\');'%(url, s_par, b_par)
if (bottom != 0) or (side != 0):
b_par = "-" + str(int(bottom))
s_par = "-" + str(int(side))
tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\')'%(url, s_par, b_par)
tag += '</script>'	tag += '</script>'
if bt.isN4:	if bt['isN4']:
tag += '</ilayer>'	tag += '</ilayer>'
else:	else:
tag += '</div>'	tag += '</div>'
return tag	return tag

def createScalerDiv(self):	def createScalerDiv(self, requestString = None, bottom = 0, side = 0, width=500, height=500):
"""generate scaler img and table with navigation arrows"""	"""generate scaler img and table with navigation arrows"""
self.checkQuery()	self.checkQuery()
	if requestString != None or bottom != 0 or side != 0:
	self.REQUEST.SESSION['scalerDiv'] = (requestString, bottom, side, width, height)
	else:
	if self.REQUEST.SESSION.has_key('scalerDiv'):
	# make shure to remove unused parameter
	del self.REQUEST.SESSION['scalerDiv']

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

Line 501 class zogiLib(Folder):	Line 496 class zogiLib(Folder):
"""generate other divs"""	"""generate other divs"""
self.checkQuery()	self.checkQuery()
bt = self.REQUEST.SESSION['browserType']	bt = self.REQUEST.SESSION['browserType']
if bt.isN4:	if bt['staticHTML']:
	return
	if bt['isN4']:
f = 'zpt/zogilib_divsN4.zpt'	f = 'zpt/zogilib_divsN4.zpt'
else:	else:
f = 'zpt/zogilib_divs.zpt'	f = 'zpt/zogilib_divs.zpt'
Line 510 class zogiLib(Folder):	Line 507 class zogiLib(Folder):


def option_js(self):	def option_js(self):
"""option_js"""	"""javascript"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/option_js')).__of__(self)	return sendFile(self, 'js/option.js', 'text/plain')
return pt()

def dl_lib_js(self):	def dl_lib_js(self):
"""javascript"""	"""javascript"""
Line 524 class zogiLib(Folder):	Line 520 class zogiLib(Folder):

def optionwindow(self):	def optionwindow(self):
"""showoptions"""	"""showoptions"""
	self.checkQuery()
	bt = self.REQUEST.SESSION['browserType']
	if bt['staticHTML']:
	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
	else:
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
return pt()	return pt()

Line 595 class zogiLib(Folder):	Line 596 class zogiLib(Folder):

def index_html(self):	def index_html(self):
"""main action"""	"""main action"""
	self.checkQuery()
	bt = self.REQUEST.SESSION['browserType']
tp = "zogiLibMainTemplate"	tp = "zogiLibMainTemplate"
if hasattr(self, tp):	if hasattr(self, tp):
pt = getattr(self, tp)	pt = getattr(self, tp)
else:	else:
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%self.layout)).__of__(self)	tpt = self.layout
	if bt['staticHTML']:
	tpt = "static"

	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)

return pt()	return pt()


Line 616 class zogiLib(Folder):	Line 624 class zogiLib(Folder):
pv = fm.split('=')	pv = fm.split('=')
dlParams[pv[0]] = pv[1]	dlParams[pv[0]] = pv[1]
except:	except:
print "ouch!"	pass

# parse digilib mode parameter	# parse digilib mode parameter
if 'mo' in dlParams:	if 'mo' in dlParams:
if len(dlParams['mo']) > 0:	if len(dlParams['mo']) > 0:
Line 627 class zogiLib(Folder):	Line 636 class zogiLib(Folder):
self.REQUEST.SESSION['query'] = dlParams	self.REQUEST.SESSION['query'] = dlParams
self.REQUEST.SESSION['dlModes'] = modes	self.REQUEST.SESSION['dlModes'] = modes
self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()	self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()
self.REQUEST.SESSION['browserType'] = BrowserCheck(self)	if not self.REQUEST.SESSION.has_key('browserType'):
	self.REQUEST.SESSION['browserType'] = browserCheck(self)

	return

def checkQuery(self):	def checkQuery(self):
"""check if the query has been stored"""	"""check if the query has been stored"""
if not (self.REQUEST.SESSION):	if not (self.REQUEST.SESSION and self.REQUEST.SESSION.has_key('query')) :
print "ZOGILIB: have to store query!!"	print "ZOGILIB: have to store query!!"
storeQuery(self)	self.storeQuery()
	return

def zogilibPath(self):	def zogilibPath(self, otherbase=None):
"""returns an URL to the zogiLib instance"""	"""returns an URL to the zogiLib instance"""
url = self.REQUEST['URL1']	url = self.REQUEST['URL1']
	# should end with "/"
	if len(url) > 0 and url[-1] != '/':
	url += '/'
	if type(otherbase) is str:
	url += otherbase
	else:
url += self.basePath	url += self.basePath
# should end with "/"	# should end with "/"
if len(url) > 0 and url[-1] != '/':	if len(url) > 0 and url[-1] != '/':
Line 649 class zogiLib(Folder):	Line 668 class zogiLib(Folder):
try:	try:
return self.REQUEST.SESSION['query'][param]	return self.REQUEST.SESSION['query'][param]
except:	except:
return None	return

def setDLParam(self, param, value):	def setDLParam(self, param, value):
"""sets parameter"""	"""sets parameter"""
Line 665 class zogiLib(Folder):	Line 684 class zogiLib(Folder):
# assemble query string	# assemble query string
ret = ""	ret = ""
for param in dlParams.keys():	for param in dlParams.keys():
	if dlParams[param] is None: continue
val = str(dlParams[param])	val = str(dlParams[param])
if val != "":	if val != "":
ret += param + "=" + val + "&"	ret += param + "=" + val + "&"

# omit trailing "&"	# omit trailing "&"
return ret.rstrip('&')	return ret.rstrip('&')

Line 696 class zogiLib(Folder):	Line 717 class zogiLib(Folder):
else:	else:
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)	self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)


	def getDLTarget(self):
	"""returns dlTarget"""
	self.checkQuery()
	s = self.dlTarget
	# s = 'dl'
	# if self.getDLParam('fn'):
	# s += "_" + self.getDLParam('fn')
	# if self.getDLParam('pn'):
	# s += "_" + self.getDLParam('pn')
	return s

	def setStaticHTML(self, static=True):
	"""sets the preference to static HTML"""
	self.checkQuery()
	self.REQUEST.SESSION['browserType']['staticHTML'] = static
	return

	def isStaticHTML(self):
	"""returns if the page is using static HTML only"""
	self.checkQuery()
	return self.REQUEST.SESSION['browserType']['staticHTML']

def getPT(self):	def getPT(self):
"""pagenums"""	"""pagenums"""
di = self.REQUEST.SESSION['dlInfo']	di = self.REQUEST.SESSION['dlInfo']
Line 707 class zogiLib(Folder):	Line 751 class zogiLib(Folder):
def getPN(self):	def getPN(self):
"""Pagenum"""	"""Pagenum"""
pn = self.getDLParam('pn')	pn = self.getDLParam('pn')
if pn:	try:
return int(pn)	return int(pn)
else:	except:
return 1	return 1

def getBiggerWS(self):	def getBiggerWS(self):
"""ws+1"""	"""ws+1"""
ws = self.getDLParam('ws')	ws = self.getDLParam('ws')
print "ws: ", ws	try:
if ws:	return float(ws)+0.5
print "WS!"	except:
return int(ws)+1	return 1.5
else:
return 2

def getSmallerWS(self):	def getSmallerWS(self):
"""ws-1"""	"""ws-1"""
ws=self.getDLParam('ws')	ws=self.getDLParam('ws')
if ws:	try:
return max(int(ws)-1, 1)	return max(float(ws)-0.5, 1)
else:	except:
return 1	return 1

def hasMode(self, mode):	def hasMode(self, mode):
Line 768 class zogiLib(Folder):	Line 810 class zogiLib(Folder):
return (wy + wh < 1)	return (wy + wh < 1)


	def dl_StaticHTML(self):
	"""set rendering to static HTML"""
	self.checkQuery()
	self.REQUEST.SESSION['browserType']['staticHTML'] = True
	return self.display()

	def dl_DynamicHTML(self):
	"""set rendering to dynamic HTML"""
	self.checkQuery()
	self.REQUEST.SESSION['browserType']['staticHTML'] = False
	return self.display()

def dl_HMirror(self):	def dl_HMirror(self):
"""mirror action"""	"""mirror action"""
modes = self.REQUEST.SESSION['dlModes']	modes = self.REQUEST.SESSION['dlModes']
Line 802 class zogiLib(Folder):	Line 856 class zogiLib(Folder):
wh2 = max(min(wh2, 1), 0)	wh2 = max(min(wh2, 1), 0)
wx = max(min(wx, 1), 0)	wx = max(min(wx, 1), 0)
wy = max(min(wy, 1), 0)	wy = max(min(wy, 1), 0)
self.setDLParam('ww', ww2)	self.setDLParam('ww', cropf(ww2))
self.setDLParam('wh', wh2)	self.setDLParam('wh', cropf(wh2))
self.setDLParam('wx', wx)	self.setDLParam('wx', cropf(wx))
self.setDLParam('wy', wy)	self.setDLParam('wy', cropf(wy))
return self.display()	return self.display()

def dl_ZoomIn(self):	def dl_ZoomIn(self):
Line 828 class zogiLib(Folder):	Line 882 class zogiLib(Folder):
wy += dy * 0.5 * wh	wy += dy * 0.5 * wh
wx = max(min(wx, 1), 0)	wx = max(min(wx, 1), 0)
wy = max(min(wy, 1), 0)	wy = max(min(wy, 1), 0)
self.setDLParam('wx', wx)	self.setDLParam('wx', cropf(wx))
self.setDLParam('wy', wy)	self.setDLParam('wy', cropf(wy))
return self.display()	return self.display()

def dl_MoveLeft(self):	def dl_MoveLeft(self):
Line 908 class zogiLib(Folder):	Line 962 class zogiLib(Folder):
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
return pt()	return pt()

def changeZogiLib(self,title,digilibBaseUrl, localFileBase, version, basePath, RESPONSE=None):	def changeZogiLib(self,title,digilibBaseUrl, localFileBase, version, basePath, dlTarget, RESPONSE=None):
"""change it"""	"""change it"""
self.title=title	self.title=title
self.digilibBaseUrl=digilibBaseUrl	self.digilibBaseUrl=digilibBaseUrl
self.localFileBase=localFileBase	self.localFileBase=localFileBase
self.basePath = basePath	self.basePath = basePath
self.layout=version	self.layout=version
	if dlTarget:
	self.dlTarget = dlTarget
	else:
	self.dlTarget = "digilib"

if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')
Line 925 def manage_addZogiLibForm(self):	Line 983 def manage_addZogiLibForm(self):
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
return pt()	return pt()

def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",basePath="",RESPONSE=None):	def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",basePath="",dlTarget="digilib",RESPONSE=None):
"""add dgilib"""	"""add dgilib"""
newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version, basePath)	newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version, basePath, dlTarget)
self.Destination()._setObject(id,newObj)	self.Destination()._setObject(id,newObj)
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')


	class zogiLibPageTemplate(ZopePageTemplate):
	"""pageTemplate Objekt"""
	meta_type="zogiLib_pageTemplate"


	## def __init__(self, id, text=None, contentType=None):
	## self.id = str(id)
	## self.ZBindings_edit(self._default_bindings)
	## if text is None:
	## text = open(self._default_cont).read()
	## self.pt_edit(text, contentType)

	def manage_addZogiLibPageTemplateForm(self):
	"""Form for adding"""
	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
	return pt()

	def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,
	REQUEST=None, submit=None):
	"Add a Page Template with optional file content."

	id = str(id)
	self._setObject(id, zogiLibPageTemplate(id))
	ob = getattr(self, id)
	if not layout: layout = "book"
	ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/zogiLibMain_%s.zpt'%layout)).read(),None)
	if title:
	ob.pt_setTitle(title)
	try:
	u = self.DestinationURL()
	except AttributeError:
	u = REQUEST['URL1']

	u = "%s/%s" % (u, urllib.quote(id))
	REQUEST.RESPONSE.redirect(u+'/manage_main')
	return ''

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

Removed from v.1.23
changed lines
	Added in v.1.30