version 1.29, 2004/06/22 17:09:13
|
version 1.46, 2004/10/05 17:43:53
|
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 |
import types |
|
import random |
from Globals import package_home |
from Globals import package_home |
|
|
ZOGIVERSION = "0.9.4 ROC:22.6.2004" |
ZOGIVERSION = "0.9.10b ROC:5.10.2004" |
|
|
|
def cropf(f): |
|
"""returns a float with reduced precision""" |
|
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 (from the product) as response""" |
paths = filename.split('/') |
paths = filename.split('/') |
object = self |
object = self |
# look for an object called filename |
# look for an object called filename |
Line 57 def browserCheck(self):
|
Line 62 def browserCheck(self):
|
|
|
return bt |
return bt |
|
|
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) |
|
|
|
|
|
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): |
"""einzelnes Image""" |
"""einzelnes Image""" |
Line 114 class zogiImage(Image):
|
Line 76 class zogiImage(Image):
|
"""init""" |
"""init""" |
self.id=id |
self.id=id |
self.title=title |
self.title=title |
|
if baseUrl: |
self.baseUrl=baseUrl |
self.baseUrl=baseUrl |
|
else: |
|
self.baseUrl="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?" |
|
|
self.queryString=queryString |
self.queryString=queryString |
self.content_type=content_type |
self.content_type=content_type |
self.precondition=precondition |
self.precondition=precondition |
Line 137 class zogiImage(Image):
|
Line 103 class zogiImage(Image):
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
|
def index_html(self, REQUEST, RESPONSE): |
def index_html(self, REQUEST, RESPONSE): |
|
"""service the request by redirecting to digilib server""" |
|
print "REDIRECT: ", self.baseUrl+self.queryString |
|
RESPONSE.redirect(self.baseUrl+self.queryString) |
|
return '' |
|
|
|
def index_html2(self, REQUEST, RESPONSE): |
""" |
""" |
Modified version of OFS/Image.py |
Modified version of OFS/Image.py |
|
|
Line 389 class zogiImage(Image):
|
Line 360 class zogiImage(Image):
|
# for a cache manager to set response headers. |
# for a cache manager to set response headers. |
self.ZCacheable_set(None) |
self.ZCacheable_set(None) |
|
|
|
#return "zogiimage: "+self.baseUrl+self.queryString |
data=urllib.urlopen(self.baseUrl+self.queryString).read() |
data=urllib.urlopen(self.baseUrl+self.queryString).read() |
|
|
if type(data) is type(''): |
if type(data) is type(''): |
Line 409 def manage_addZogiImageForm(self):
|
Line 381 def manage_addZogiImageForm(self):
|
|
|
|
|
def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None): |
def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None): |
"""add dgilib""" |
"""add zogiimage""" |
newObj=zogiImage(id,title,baseUrl, queryString) |
newObj=zogiImage(id,title,baseUrl, queryString) |
self.Destination()._setObject(id,newObj) |
self.Destination()._setObject(id,newObj) |
if RESPONSE is not None: |
if RESPONSE is not None: |
Line 421 class zogiLib(Folder):
|
Line 393 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", basePath="", dlTarget=None): |
def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None): |
"""init""" |
"""init""" |
|
|
self.id=id |
self.id=id |
self.title=title |
self.title=title |
self.digilibBaseUrl=digilibBaseUrl |
self.dlServerURL = dlServerURL |
self.localFileBase=localFileBase |
|
self.basePath=basePath |
self.basePath=basePath |
self.layout=version |
self.layout=layout |
if dlTarget: |
|
self.dlTarget = dlTarget |
self.dlTarget = dlTarget |
|
|
|
if dlToolbarBaseURL: |
|
self.dlToolbarBaseURL = dlToolbarBaseURL |
else: |
else: |
self.dlTarget = "digilib" |
self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?" |
|
|
|
|
def version(self): |
def version(self): |
"""version information""" |
"""version information""" |
return ZOGIVERSION |
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 [] |
|
|
|
|
|
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) |
params=dom.getElementsByTagName('parameter') |
params=dom.getElementsByTagName('parameter') |
for param in params: |
for param in params: |
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() |
self.checkQuery() |
bt = self.REQUEST.SESSION['browserType'] |
bt = self.REQUEST.SESSION.get('browserType', {}) |
if bt['staticHTML']: |
if bt['staticHTML']: |
return |
return |
|
|
Line 490 class zogiLib(Folder):
|
Line 578 class zogiLib(Folder):
|
# if not explicitly defined take normal request |
# 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.dlServerURL+'/servlet/Scaler?'+requestString |
# construct bottom and side insets |
# construct bottom and side insets |
b_par = "" |
b_par = "" |
s_par = "" |
s_par = "" |
Line 550 class zogiLib(Folder):
|
Line 638 class zogiLib(Folder):
|
|
|
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""" |
Line 563 class zogiLib(Folder):
|
Line 651 class zogiLib(Folder):
|
if bt['staticHTML']: |
if bt['staticHTML']: |
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self) |
else: |
else: |
|
tp = "viewingTools.zpt" |
|
if hasattr(self, tp): |
|
pt = getattr(self, tp) |
|
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() |
|
|
def mark1(self): |
def mark1(self): |
Line 637 class zogiLib(Folder):
|
Line 730 class zogiLib(Folder):
|
self.checkQuery() |
self.checkQuery() |
bt = self.REQUEST.SESSION['browserType'] |
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: |
tpt = self.layout |
tpt = self.layout |
|
|
if bt['staticHTML']: |
if bt['staticHTML']: |
tpt = "static" |
tpt = "static" |
|
|
Line 649 class zogiLib(Folder):
|
Line 744 class zogiLib(Folder):
|
return pt() |
return pt() |
|
|
|
|
|
|
def storeQuery(self, more = None): |
def storeQuery(self, more = None): |
"""storeQuery in session""" |
"""storeQuery in session""" |
dlParams = {} |
dlParams = {} |
Line 671 class zogiLib(Folder):
|
Line 765 class zogiLib(Folder):
|
else: |
else: |
modes=[] |
modes=[] |
|
|
self.REQUEST.SESSION['query'] = dlParams |
wid = self.getWID() |
self.REQUEST.SESSION['dlModes'] = modes |
self.REQUEST.set('wid', wid) |
self.REQUEST.SESSION['dlInfo'] = self.getDLInfo() |
self.setSubSession('dlQuery', dlParams) |
|
self.setSubSession('dlModes', modes) |
|
self.setSubSession('dlInfo', self.getDLInfo()) |
if not self.REQUEST.SESSION.has_key('browserType'): |
if not self.REQUEST.SESSION.has_key('browserType'): |
self.REQUEST.SESSION['browserType'] = browserCheck(self) |
self.REQUEST.SESSION['browserType'] = browserCheck(self) |
|
|
Line 681 class zogiLib(Folder):
|
Line 777 class zogiLib(Folder):
|
|
|
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 self.REQUEST.SESSION.has_key('query')) : |
if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) : |
print "ZOGILIB: have to store query!!" |
print "ZOGILIB: have to store query!!" |
self.storeQuery() |
self.storeQuery() |
return |
return |
Line 701 class zogiLib(Folder):
|
Line 797 class zogiLib(Folder):
|
url += '/' |
url += '/' |
return url |
return url |
|
|
|
def zogilibAction(self, action, otherbase=None, wid=None): |
|
"""returns a URL with zogilib path, action and wid""" |
|
url = self.zogilibPath(otherbase) |
|
url += action |
|
if wid: |
|
url += '?wid=' + wid |
|
else: |
|
url += '?wid=' + self.getWID() |
|
return url |
|
|
|
def getSubSession(self, key, default=None): |
|
"""returns an element from a session with a wid""" |
|
wid = self.getWID() |
|
return self.REQUEST.SESSION.get(key+'_'+wid, default) |
|
|
|
def setSubSession(self, key, value): |
|
"""puts an element in a session with a wid""" |
|
wid = self.getWID() |
|
self.REQUEST.SESSION.set(key+'_'+wid, value) |
|
return |
|
|
|
def getWID(self): |
|
"""returns a (new) window id""" |
|
wid = self.REQUEST.get('wid') |
|
if not wid: |
|
wid = 'digi_'+str(int(random.random()*10000)) |
|
print "new WID:", wid |
|
return wid |
|
|
def getDLParam(self, param): |
def getDLParam(self, param): |
"""returns parameter""" |
"""returns parameter""" |
try: |
try: |
return self.REQUEST.SESSION['query'][param] |
return self.getSubSession('dlQuery').get(param) |
except: |
except: |
return |
return |
|
|
def setDLParam(self, param, value): |
def setDLParam(self, param, value): |
"""sets parameter""" |
"""sets parameter""" |
self.REQUEST.SESSION['query'][param] = value |
dlParams = self.getSubSession('dlQuery') |
|
#try: |
|
dlParams[param] = value |
|
#except: |
|
# self.setSubSession('dlQuery', {param: value}) |
return |
return |
|
|
def getAllDLParams(self): |
def getAllDLParams(self): |
"""parameter string for digilib""" |
"""parameter string for digilib""" |
dlParams = self.REQUEST.SESSION['query'] |
dlParams = self.getSubSession('dlQuery') |
# save modes |
# save modes |
modes = self.REQUEST.SESSION['dlModes'] |
modes = self.getSubSession('dlModes') |
dlParams['mo'] = string.join(modes, ',') |
dlParams['mo'] = string.join(modes, ',') |
# assemble query string |
# assemble query string |
ret = "" |
ret = "" |
Line 749 class zogiLib(Folder):
|
Line 878 class zogiLib(Folder):
|
|
|
def display(self): |
def display(self): |
"""(re)display page""" |
"""(re)display page""" |
|
if not self.getDLParam('wid'): |
|
wid = self.getWID() |
|
self.setDLParam('wid', wid) |
|
|
params = self.getAllDLParams() |
params = self.getAllDLParams() |
|
|
if self.basePath: |
if self.basePath: |
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params) |
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params) |
else: |
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.dlToolbarBaseURL+self.getAllDLParams() |
|
return url |
|
|
|
def getDLTarget(self): |
|
"""returns dlTarget""" |
|
self.checkQuery() |
|
s = self.dlTarget |
|
if s == None: |
|
s = "" |
|
# 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): |
def setStaticHTML(self, static=True): |
"""sets the preference to static HTML""" |
"""sets the preference to static HTML""" |
Line 769 class zogiLib(Folder):
|
Line 924 class zogiLib(Folder):
|
|
|
def getPT(self): |
def getPT(self): |
"""pagenums""" |
"""pagenums""" |
di = self.REQUEST.SESSION['dlInfo'] |
di = self.getSubSession('dlInfo_') |
if di: |
if di: |
return int(di['pt']) |
return int(di['pt']) |
else: |
else: |
Line 801 class zogiLib(Folder):
|
Line 956 class zogiLib(Folder):
|
|
|
def hasMode(self, mode): |
def hasMode(self, mode): |
"""returns if mode is in the diglib mo parameter""" |
"""returns if mode is in the diglib mo parameter""" |
return (mode in self.REQUEST.SESSION['dlModes']) |
wid = self.getWID() |
|
return (mode in self.REQUEST.SESSION['dlModes_'+wid]) |
|
|
def hasNextPage(self): |
def hasNextPage(self): |
"""returns if there is a next page""" |
"""returns if there is a next page""" |
Line 851 class zogiLib(Folder):
|
Line 1007 class zogiLib(Folder):
|
|
|
def dl_HMirror(self): |
def dl_HMirror(self): |
"""mirror action""" |
"""mirror action""" |
modes = self.REQUEST.SESSION['dlModes'] |
modes = self.getSubSession('dlModes') |
if 'hmir' in modes: |
if 'hmir' in modes: |
modes.remove('hmir') |
modes.remove('hmir') |
else: |
else: |
Line 861 class zogiLib(Folder):
|
Line 1017 class zogiLib(Folder):
|
|
|
def dl_VMirror(self): |
def dl_VMirror(self): |
"""mirror action""" |
"""mirror action""" |
modes = self.REQUEST.SESSION['dlModes'] |
modes = self.getSubSession('dlModes') |
if 'vmir' in modes: |
if 'vmir' in modes: |
modes.remove('vmir') |
modes.remove('vmir') |
else: |
else: |
Line 883 class zogiLib(Folder):
|
Line 1039 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 909 class zogiLib(Folder):
|
Line 1065 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 982 class zogiLib(Folder):
|
Line 1138 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, basePath, dlTarget, RESPONSE=None): |
def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None): |
"""change it""" |
"""change it""" |
self.title=title |
self.title=title |
self.digilibBaseUrl=digilibBaseUrl |
self.dlServerURL=dlServerURL |
self.localFileBase=localFileBase |
|
self.basePath = basePath |
self.basePath = basePath |
self.layout=version |
self.layout=version |
if dlTarget: |
|
self.dlTarget = dlTarget |
self.dlTarget = dlTarget |
|
|
|
if dlToolbarBaseURL: |
|
self.dlToolbarBaseURL = dlToolbarBaseURL |
else: |
else: |
self.dlTarget = "digilib" |
self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?" |
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
|
|
|
|
## |
|
## odds and ends |
|
## |
|
|
|
def repairZogilib(self, obj=None): |
|
"""change stuff that broke on upgrading""" |
|
|
|
msg = "" |
|
|
|
if not obj: |
|
obj = self.getPhysicalRoot() |
|
|
|
print "starting in ", obj |
|
|
|
entries=obj.ZopeFind(obj,obj_metatypes=['zogiLib'],search_sub=1) |
|
|
|
for entry in entries: |
|
print " found ", entry |
|
# |
|
# replace digilibBaseUrl by dlServerURL |
|
if hasattr(entry[1], 'digilibBaseUrl'): |
|
msg += " fixing digilibBaseUrl in "+entry[0]+"\n" |
|
entry[1].dlServerURL = re.sub('/servlet/Scaler\?','',entry[1].digilibBaseUrl) |
|
del entry[1].digilibBaseUrl |
|
|
|
# |
|
# add dlToolbarBaseURL |
|
if not hasattr(entry[1], 'dlToolbarBaseURL'): |
|
msg += " fixing dlToolbarBaseURL in "+entry[0]+"\n" |
|
entry[1].dlToolbarBaseURL = entry[1].dlServerURL + "/digimage.jsp?" |
|
|
|
return msg+"\n\nfixed all zogilib instances in: "+obj.title |
|
|
|
|
def manage_addZogiLibForm(self): |
def manage_addZogiLibForm(self): |
"""interface for adding zogilib""" |
"""interface for adding zogilib""" |
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="",dlTarget="digilib",RESPONSE=None): |
def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None): |
"""add dgilib""" |
"""add dgilib""" |
newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version, basePath, dlTarget) |
newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL) |
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') |
Line 1054 def manage_addZogiLibPageTemplate(self,
|
Line 1249 def manage_addZogiLibPageTemplate(self,
|
u = "%s/%s" % (u, urllib.quote(id)) |
u = "%s/%s" % (u, urllib.quote(id)) |
REQUEST.RESPONSE.redirect(u+'/manage_main') |
REQUEST.RESPONSE.redirect(u+'/manage_main') |
return '' |
return '' |
|
|