version 1.20, 2004/06/02 19:01:36
|
version 1.34, 2004/07/21 17:44:51
|
Line 1
|
Line 1
|
|
|
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Products.PageTemplates.PageTemplate import PageTemplate |
from Products.PageTemplates.PageTemplate import PageTemplate |
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
Line 7 from webdav.common import rfc1123_date
|
Line 6 from webdav.common import rfc1123_date
|
|
|
import xml.dom.minidom |
import xml.dom.minidom |
from OFS.Folder import Folder |
from OFS.Folder import Folder |
from xml_helpers import getText |
from xml_helpers import getUniqueElementText,getText |
import os |
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.7 ROC:21.7.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 42 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, |
|
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) |
|
|
|
|
return bt |
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 422 class zogiLib(Folder):
|
Line 382 class zogiLib(Folder):
|
"""StandardElement""" |
"""StandardElement""" |
|
|
meta_type="zogiLib" |
meta_type="zogiLib" |
|
#xxxx |
|
|
manage_options = Folder.manage_options+( |
manage_options = Folder.manage_options+( |
{'label':'Main Config','action':'changeZogiLibForm'}, |
{'label':'Main Config','action':'changeZogiLibForm'}, |
) |
) |
|
|
def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"): |
def __init__(self, id, title, digilibBaseURL,localFileBase, version="book", basePath="", dlTarget=None, dlServerURL=None): |
"""init""" |
"""init""" |
|
|
self.id=id |
self.id=id |
self.title=title |
self.title=title |
self.digilibBaseUrl=digilibBaseUrl |
self.digilibBaseURL=digilibBaseURL |
|
self.dlServerURL = dlServerURL |
|
if digilibBaseURL and not dlServerURL: |
|
self.dlServerURL = re.sub("/servlet/Scaler\?","",self.digilibBaseURL) |
|
|
self.localFileBase=localFileBase |
self.localFileBase=localFileBase |
|
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 getContextStatic(self): |
|
"""get all the contexts which go to static pages""" |
|
|
|
try: |
|
dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName())) |
|
contexts=dom.getElementsByTagName("context") |
|
|
|
ret=[] |
|
for context in contexts: |
|
name=getUniqueElementText(context.getElementsByTagName("name")) |
|
|
|
link=getUniqueElementText(context.getElementsByTagName("link")) |
|
if name or link: |
|
ret.append((name,link)) |
|
return ret |
|
except: |
|
return [] |
|
|
|
def getContextDatabases(self): |
|
"""get all dynamic contexts""" |
|
try: |
|
dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName())) |
|
contexts=dom.getElementsByTagName("context") |
|
ret=[] |
|
for context in contexts: |
|
metaDataLinks=context.getElementsByTagName("meta-datalink") |
|
for metaDataLink in metaDataLinks: |
|
db=metaDataLink.getAttribute("db") |
|
link=self.REQUEST['URL1']+"/dl_db?db=%s"%db |
|
if db: |
|
ret.append((db,link)) |
|
metaDataLinks=context.getElementsByTagName("meta-baselink") |
|
|
|
for metaDataLink in metaDataLinks: |
|
db=metaDataLink.getAttribute("db") |
|
link=self.REQUEST['URL1']+"/dl_db?db=%s"%db |
|
if db: |
|
ret.append((db,link)) |
|
|
|
return ret |
|
except: |
|
return ret |
|
|
|
def formatHTML(self,url,label=None,viewUrl=None): |
|
|
|
|
|
sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset') |
|
ret="" |
|
print label |
|
if label: |
|
ret+="""<a href="%s">%s</a>"""%(viewUrl,label) |
|
for set in sets: |
|
ret+="<table>" |
|
for node in set.childNodes: |
|
if hasattr(node,'tagName'): |
|
tag=node.tagName |
|
label=node.getAttribute("label") |
|
if not label: |
|
label=tag |
|
text=getText(node.childNodes) |
|
ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text) |
|
ret+="</table>" |
|
return ret |
|
|
|
def getMetaData(self): |
|
"""getMetaData""" |
|
try: |
|
dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName())) |
|
except: |
|
return "error metadata" |
|
|
|
contexts=dom.getElementsByTagName("context") |
|
ret=[] |
|
db=self.getDLParam("db") |
|
ob=self.getDLParam("object") |
|
|
|
fn=self.getDLParam("fn") |
|
pn=self.getDLParam("pn") |
|
if not fn: |
|
fn="" |
|
if not pn: |
|
pn="" |
|
if not ob: |
|
ob="" |
|
|
|
for context in contexts: |
|
metaDataLinks=context.getElementsByTagName("meta-datalink") |
|
for metaDataLink in metaDataLinks: |
|
|
|
if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1): |
|
|
|
link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url")) |
|
label=getUniqueElementText(metaDataLink.getElementsByTagName("label")) |
|
url=getUniqueElementText(metaDataLink.getElementsByTagName("url")) |
|
|
|
return self.formatHTML(link,label,url) |
|
|
|
metaDataLinks=context.getElementsByTagName("meta-baselink") |
|
|
|
for metaDataLink in metaDataLinks: |
|
|
|
if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1): |
|
|
|
link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url")) |
|
label=getUniqueElementText(metaDataLink.getElementsByTagName("label")) |
|
url=getUniqueElementText(metaDataLink.getElementsByTagName("url")) |
|
|
|
return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url) |
|
return ret |
|
|
def getDLInfo(self): |
def getDLInfo(self): |
"""get DLInfo from digilib server""" |
"""get DLInfo from digilib server""" |
paramH={} |
paramH={} |
baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl) |
baseUrl=self.dlServerURL+"/dlInfo-xml.jsp" |
try: |
try: |
url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING']) |
url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING']) |
dom=xml.dom.minidom.parse(url) |
dom=xml.dom.minidom.parse(url) |
Line 449 class zogiLib(Folder):
|
Line 532 class zogiLib(Folder):
|
paramH[param.getAttribute('name')]=param.getAttribute('value') |
paramH[param.getAttribute('name')]=param.getAttribute('value') |
return paramH |
return paramH |
except: |
except: |
return null |
return {} |
|
|
|
|
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): |
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.REQUEST.QUERY_STRING |
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'));" |
tag += 'document.write(\'<img id="pic" src="%s&dw=\'+ps.width+\'&dh=\'+ps.height+\'" />\')'%url |
# write img tag with javascript |
|
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, requestString = None, bottom = 0, side = 0, width=500, height=500): |
|
"""generate scaler img and table with navigation arrows""" |
|
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) |
|
return pt() |
|
|
def createAuxDiv(self): |
def createAuxDiv(self): |
"""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 498 class zogiLib(Folder):
|
Line 621 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""" |
return sendFile(self, 'js/dl_lib.js', 'text/plain') |
return sendFile(self, 'js/dllib.js', 'text/plain') |
|
|
def js_lib_js(self): |
def js_lib_js(self): |
"""javascript""" |
"""javascript""" |
return sendFile(self, 'js/js_lib.js', 'text/plain') |
return sendFile(self, 'js/baselib.js', 'text/plain') |
|
|
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: |
|
finds=self.ZopeFind(self,obj_ids=['viewingTools.zpt']) |
|
if finds: |
|
|
|
return finds[0][1]() |
|
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 563 class zogiLib(Folder):
|
Line 695 class zogiLib(Folder):
|
"""mark image""" |
"""mark image""" |
return sendFile(self, 'images/urechts.gif', 'image/gif') |
return sendFile(self, 'images/urechts.gif', 'image/gif') |
|
|
|
def up_img(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/up.gif', 'image/gif') |
|
|
|
def down_img(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/down.gif', 'image/gif') |
|
|
|
def left_img(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/left.gif', 'image/gif') |
|
|
|
def right_img(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/right.gif', 'image/gif') |
|
|
|
|
|
|
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() |
|
|
|
|
|
|
def storeQuery(self): |
def storeQuery(self, more = None): |
"""storeQuery in session""" |
"""storeQuery in session""" |
dlParams = {} |
dlParams = {} |
for fm in self.REQUEST.form.keys(): |
for fm in self.REQUEST.form.keys(): |
dlParams[fm] = self.REQUEST.form[fm] |
dlParams[fm] = self.REQUEST.form[fm] |
|
# look for more |
|
if more: |
|
for fm in more.split('&'): |
|
try: |
|
pv = fm.split('=') |
|
dlParams[pv[0]] = pv[1] |
|
except: |
|
pass |
|
|
|
# parse digilib mode parameter |
if 'mo' in dlParams: |
if 'mo' in dlParams: |
if len(dlParams['mo']) > 0: |
if len(dlParams['mo']) > 0: |
modes=dlParams['mo'].split(',') |
modes=dlParams['mo'].split(',') |
Line 592 class zogiLib(Folder):
|
Line 757 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 and 'query' in 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, otherbase=None): |
|
"""returns an URL to the zogiLib instance""" |
|
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 |
|
# should end with "/" |
|
if len(url) > 0 and url[-1] != '/': |
|
url += '/' |
|
return url |
|
|
def getDLParam(self,param): |
def getDLParam(self,param): |
"""returns parameter""" |
"""returns parameter""" |
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 621 class zogiLib(Folder):
|
Line 805 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('&') |
|
|
|
|
def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None): |
def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None): |
"""setze Parameter""" |
"""setze Parameter""" |
ret="" |
|
|
|
if brgt: |
|
self.setDLParam('brgt', brgt) |
self.setDLParam('brgt', brgt) |
|
|
if cont: |
|
self.setDLParam('cont', cont) |
self.setDLParam('cont', cont) |
|
self.setDLParam('ws', ws) |
|
self.setDLParam('rot', rot) |
|
|
if pn: |
if pn: |
|
# unmark |
|
self.setDLParam('mk', None) |
self.setDLParam('pn', pn) |
self.setDLParam('pn', pn) |
|
|
if ws: |
|
self.setDLParam('ws', ws) |
|
|
|
if rot: |
|
self.setDLParam('rot', rot) |
|
|
|
return self.display() |
return self.display() |
|
|
|
|
def display(self): |
def display(self): |
"""(re)display page""" |
"""(re)display page""" |
params = self.getAllDLParams() |
params = self.getAllDLParams() |
|
if self.basePath: |
|
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params) |
|
else: |
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params) |
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params) |
|
|
|
def getMetaFileName(self): |
|
url=self.dlServerURL+'/dlContext-xml.jsp?'+self.getAllDLParams() |
|
return urlbase |
|
|
|
def getToolbarPageURL(self): |
|
"""returns a toolbar-enabled page URL""" |
|
url=self.dlServerURL+'/digimage.jsp?'+self.getAllDLParams() |
|
return url |
|
|
|
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 666 class zogiLib(Folder):
|
Line 880 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') |
if ws: |
try: |
return int(ws)+1 |
return float(ws)+0.5 |
else: |
except: |
return 2 |
return 1.5 |
|
|
|
|
def getSmallerWS(self): |
def getSmallerWS(self): |
"""ws-1""" |
"""ws-1""" |
ws=self.getDLParam('ws') |
ws=self.getDLParam('ws') |
if ws: |
try: |
if int(ws)==1: |
return max(float(ws)-0.5, 1) |
return 1 |
except: |
else: |
|
return int(ws)-1 |
|
else: |
|
return 1 |
return 1 |
|
|
def hasMode(self, mode): |
def hasMode(self, mode): |
Line 706 class zogiLib(Folder):
|
Line 916 class zogiLib(Folder):
|
pn = self.getPN() |
pn = self.getPN() |
return (pn > 1) |
return (pn > 1) |
|
|
|
def canMoveLeft(self): |
|
"""returns if its possible to move left""" |
|
wx = float(self.getDLParam('wx') or 0) |
|
return (wx > 0) |
|
|
|
def canMoveRight(self): |
|
"""returns if its possible to move right""" |
|
wx = float(self.getDLParam('wx') or 0) |
|
ww = float(self.getDLParam('ww') or 1) |
|
return (wx + ww < 1) |
|
|
|
def canMoveUp(self): |
|
"""returns if its possible to move up""" |
|
wy = float(self.getDLParam('wy') or 0) |
|
return (wy > 0) |
|
|
|
def canMoveDown(self): |
|
"""returns if its possible to move down""" |
|
wy = float(self.getDLParam('wy') or 0) |
|
wh = float(self.getDLParam('wh') or 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""" |
Line 728 class zogiLib(Folder):
|
Line 971 class zogiLib(Folder):
|
|
|
return self.display() |
return self.display() |
|
|
|
def dl_Zoom(self, z): |
|
"""general zoom action""" |
|
ww1 = float(self.getDLParam('ww') or 1) |
|
wh1 = float(self.getDLParam('wh') or 1) |
|
wx = float(self.getDLParam('wx') or 0) |
|
wy = float(self.getDLParam('wy') or 0) |
|
ww2 = ww1 * z |
|
wh2 = wh1 * z |
|
wx += (ww1 - ww2) / 2 |
|
wy += (wh1 - wh2) / 2 |
|
ww2 = max(min(ww2, 1), 0) |
|
wh2 = max(min(wh2, 1), 0) |
|
wx = max(min(wx, 1), 0) |
|
wy = max(min(wy, 1), 0) |
|
self.setDLParam('ww', cropf(ww2)) |
|
self.setDLParam('wh', cropf(wh2)) |
|
self.setDLParam('wx', cropf(wx)) |
|
self.setDLParam('wy', cropf(wy)) |
|
return self.display() |
|
|
|
def dl_ZoomIn(self): |
|
"""zoom in action""" |
|
z = 0.7071 |
|
return self.dl_Zoom(z) |
|
|
|
def dl_ZoomOut(self): |
|
"""zoom out action""" |
|
z = 1.4142 |
|
return self.dl_Zoom(z) |
|
|
|
def dl_Move(self, dx, dy): |
|
"""general move action""" |
|
ww = float(self.getDLParam('ww') or 1) |
|
wh = float(self.getDLParam('wh') or 1) |
|
wx = float(self.getDLParam('wx') or 0) |
|
wy = float(self.getDLParam('wy') or 0) |
|
wx += dx * 0.5 * ww |
|
wy += dy * 0.5 * wh |
|
wx = max(min(wx, 1), 0) |
|
wy = max(min(wy, 1), 0) |
|
self.setDLParam('wx', cropf(wx)) |
|
self.setDLParam('wy', cropf(wy)) |
|
return self.display() |
|
|
|
def dl_MoveLeft(self): |
|
"""move left action""" |
|
return self.dl_Move(-1, 0) |
|
|
|
def dl_MoveRight(self): |
|
"""move left action""" |
|
return self.dl_Move(1, 0) |
|
|
|
def dl_MoveUp(self): |
|
"""move left action""" |
|
return self.dl_Move(0, -1) |
|
|
|
def dl_MoveDown(self): |
|
"""move left action""" |
|
return self.dl_Move(0, 1) |
|
|
def dl_WholePage(self): |
def dl_WholePage(self): |
"""zoom out action""" |
"""zoom out action""" |
self.setDLParam('ww', 1) |
self.setDLParam('ww', 1) |
Line 781 class zogiLib(Folder):
|
Line 1084 class zogiLib(Folder):
|
self.setDLParam('mk', mk) |
self.setDLParam('mk', mk) |
return self.display() |
return self.display() |
|
|
|
def dl_db(self,db): |
|
"""set db""" |
|
self.setDLParam('db',db) |
|
self.display() |
|
|
def changeZogiLibForm(self): |
def changeZogiLibForm(self): |
"""Main configuration""" |
"""Main configuration""" |
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, 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.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 804 def manage_addZogiLibForm(self):
|
Line 1115 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",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) |
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 '' |