version 1.52, 2004/11/03 15:24:46
|
version 1.60, 2005/11/08 18:10:10
|
Line 1
|
Line 1
|
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from AccessControl import ClassSecurityInfo |
|
from Globals import package_home |
|
from OFS.Folder import Folder |
|
from OFS.Image import Image |
|
from OFS.Image import File |
|
from OFS.SimpleItem import SimpleItem |
from Products.PageTemplates.PageTemplate import PageTemplate |
from Products.PageTemplates.PageTemplate import PageTemplate |
|
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
from OFS.Image import Image |
from types import * |
from webdav.common import rfc1123_date |
from Globals import package_home, ImageFile |
|
|
import xml.dom.minidom |
|
from OFS.Folder import Folder |
|
from xml_helpers import getUniqueElementText,getText |
from xml_helpers import getUniqueElementText,getText |
|
import cgi |
import os |
import os |
|
import random |
import re |
import re |
import string |
import string |
import urllib |
import urllib |
import types |
import xml.dom.minidom |
import random |
|
from Globals import package_home |
|
|
|
ZOGIVERSION = "0.9.13b ROC:3.11.2004" |
ZOGIVERSION = "0.10.1b ROC 8.11.2005" |
|
|
def cropf(f): |
def cropf(f): |
"""returns a float with reduced precision""" |
"""returns a float with reduced precision""" |
Line 71 def browserCheck(self):
|
Line 74 def browserCheck(self):
|
return bt |
return bt |
|
|
|
|
class zogiImage(Image): |
class zogiImage(SimpleItem): |
"""einzelnes Image""" |
"""einzelnes Image""" |
meta_type="zogiImage" |
meta_type="zogiImage" |
|
|
manage_options=ZopePageTemplate.manage_options+( |
manage_options=SimpleItem.manage_options+( |
{'label':'Main config','action':'changeZogiImageForm'}, |
{'label':'Main config','action':'changeZogiImageForm'}, |
) |
) |
|
|
Line 93 class zogiImage(Image):
|
Line 96 class zogiImage(Image):
|
self.content_type=content_type |
self.content_type=content_type |
self.precondition=precondition |
self.precondition=precondition |
|
|
def getData(self): |
#def getData(self): |
"""getUrlData""" |
# """getUrlData""" |
return urllib.urlopen(self.baseUrl+self.queryString) |
# return urllib.urlopen(self.baseUrl+self.queryString) |
|
|
def changeZogiImageForm(self): |
def changeZogiImageForm(self): |
"""Main configuration""" |
"""Main configuration""" |
Line 116 class zogiImage(Image):
|
Line 119 class zogiImage(Image):
|
RESPONSE.redirect(self.baseUrl+self.queryString) |
RESPONSE.redirect(self.baseUrl+self.queryString) |
return '' |
return '' |
|
|
|
def rescale(self,width=None,height=None): |
|
"""andere parameter im querystring""" |
|
qs=cgi.parse_qs(self.queryString) |
|
for x in qs.keys(): |
|
if type(qs[x]) is ListType: |
|
qs[x]=qs[x][0] |
|
|
|
if width: |
|
qs['dw']=width |
|
if height: |
|
qs['dh']=height |
|
|
|
|
|
qsneu=urllib.urlencode(qs) |
|
self.queryString=qsneu |
|
return "done" |
|
|
def manage_addZogiImageForm(self): |
def manage_addZogiImageForm(self): |
"""Form for adding""" |
"""Form for adding""" |
Line 138 class zogiLib(Folder):
|
Line 156 class zogiLib(Folder):
|
|
|
meta_type="zogiLib" |
meta_type="zogiLib" |
#xxxx |
#xxxx |
|
security=ClassSecurityInfo() |
|
|
manage_options = Folder.manage_options+( |
manage_options = Folder.manage_options+( |
{'label':'Main Config','action':'changeZogiLibForm'}, |
{'label':'Main Config','action':'changeZogiLibForm'}, |
Line 158 class zogiLib(Folder):
|
Line 177 class zogiLib(Folder):
|
else: |
else: |
self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?" |
self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?" |
|
|
|
self.manage_addFolder('template') |
|
|
|
|
|
# form templates |
|
main_book = PageTemplateFile('zpt/main_book', globals()) |
|
main_image = PageTemplateFile('zpt/main_image', globals()) |
|
main_metaData = PageTemplateFile('zpt/main_metadata', globals()) |
|
main_static = PageTemplateFile('zpt/main_static', globals()) |
|
options = PageTemplateFile('zpt/options', globals()) |
|
changeForm = PageTemplateFile('zpt/changeForm', globals()) |
|
|
|
# display templates |
|
aux_divs = PageTemplateFile('zpt/aux_divs', globals()) |
|
aux_divsN4 = PageTemplateFile('zpt/aux_divsN4', globals()) |
|
img_div = PageTemplateFile('zpt/img_div', globals()) |
|
|
|
# javascripts |
|
head_js = PageTemplateFile('zpt/head_js', globals()) |
|
jslib_js = PageTemplateFile('js/baselib.js', globals()) |
|
dllib_js = PageTemplateFile('js/dllib.js', globals()) |
|
|
|
# graphic files |
|
arr_right = ImageFile('images/right.gif', globals()) |
|
arr_left = ImageFile('images/left.gif', globals()) |
|
arr_up = ImageFile('images/up.gif', globals()) |
|
arr_down = ImageFile('images/down.gif', globals()) |
|
mark1 = ImageFile('images/mark1.gif', globals()) |
|
mark2 = ImageFile('images/mark2.gif', globals()) |
|
mark3 = ImageFile('images/mark3.gif', globals()) |
|
mark4 = ImageFile('images/mark4.gif', globals()) |
|
mark5 = ImageFile('images/mark5.gif', globals()) |
|
mark6 = ImageFile('images/mark6.gif', globals()) |
|
mark7 = ImageFile('images/mark7.gif', globals()) |
|
mark8 = ImageFile('images/mark8.gif', globals()) |
|
corner1 = ImageFile('images/olinks.gif', globals()) |
|
corner2 = ImageFile('images/orechts.gif', globals()) |
|
corner3 = ImageFile('images/ulinks.gif', globals()) |
|
corner4 = ImageFile('images/urechts.gif', globals()) |
|
|
|
|
|
security.declareProtected('View','getLayout') |
|
def getLayout(self): |
|
"""get Layout""" |
|
return self.layout |
|
|
def version(self): |
def version(self): |
"""version information""" |
"""version information""" |
Line 212 class zogiLib(Folder):
|
Line 275 class zogiLib(Folder):
|
|
|
sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset') |
sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset') |
ret="" |
ret="" |
print label |
#print label |
if label: |
if label: |
ret+="""<a href="%s">%s</a>"""%(viewUrl,label) |
ret+="""<a href="%s">%s</a>"""%(viewUrl,label) |
for set in sets: |
for set in sets: |
Line 279 class zogiLib(Folder):
|
Line 342 class zogiLib(Folder):
|
def getDLInfo(self): |
def getDLInfo(self): |
"""get DLInfo from digilib server""" |
"""get DLInfo from digilib server""" |
paramH={} |
paramH={} |
baseUrl=self.dlServerURL+"/dlInfo-xml.jsp" |
baseUrl=self.getDLBaseUrl()+"/dlInfo-xml.jsp" |
|
print "getdlinfo: ", baseUrl |
try: |
try: |
url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING']) |
url=urllib.urlopen(baseUrl+'?'+self.getAllDLParams()) |
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: |
Line 291 class zogiLib(Folder):
|
Line 355 class zogiLib(Folder):
|
return {} |
return {} |
|
|
|
|
def createHeadJS(self): |
def zogilibPath(self, otherbase=None): |
"""generate all javascript tags for head""" |
"""returns an URL to the zogiLib instance""" |
self.checkQuery() |
url = self.REQUEST['URL1'] |
bt = self.REQUEST.SESSION.get('browserType', {}) |
# should end with "/" |
if bt['staticHTML']: |
if len(url) > 0 and url[-1] != '/': |
return |
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 |
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self) |
def zogilibAction(self, action, otherbase=None): |
return pt() |
"""returns a URL with zogilib path and action""" |
|
url = self.zogilibPath(otherbase) |
|
url += action |
|
url += '?' + self.getAllDLParams(); |
|
return url |
|
|
def createParamJS(self): |
def getDLBaseUrl(self): |
"""generate javascript for parameters only""" |
"""returns digilib base URL (sans servlet path)""" |
self.checkQuery() |
if self.dlServerURL[-1] == '?': |
bt = self.REQUEST.SESSION['browserType'] |
# full Servlet URL -- remove last part |
if bt['staticHTML']: |
si = self.dlServerURL.rindex('/servlet/') |
return |
if si > 0: |
|
return self.dlServerURL[:si] |
|
else: |
|
# no servlet part :-( |
|
return "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary" |
|
else: |
|
return self.dlServerURL |
|
|
|
|
|
def getScalerUrl(self,requestString=""): |
|
"""send scaler url""" |
|
if self.dlServerURL[-1] == '?': |
|
# full Servlet URL |
|
return self.dlServerURL + requestString |
|
else: |
|
return self.dlServerURL+'/servlet/Scaler?'+requestString |
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self) |
def scaledImage(self,requestString=None): |
return pt() |
"""scaled Image""" |
|
|
|
if not requestString: |
|
requestString=self.REQUEST['QUERY_STRING'] |
|
|
|
self.REQUEST.RESPONSE.redirect(self.getScalerUrl(requestString)) |
|
|
|
return True |
|
|
|
|
def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500): |
def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500): |
Line 322 class zogiLib(Folder):
|
Line 420 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.dlServerURL+'/servlet/Scaler?'+requestString |
url = self.getScalerUrl(requestString=requestString) |
# construct bottom and side insets |
# construct bottom and side insets |
b_par = "" |
b_par = "" |
s_par = "" |
s_par = "" |
Line 362 class zogiLib(Folder):
|
Line 460 class zogiLib(Folder):
|
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() |
|
|
def createAuxDiv(self): |
|
"""generate other divs""" |
|
self.checkQuery() |
|
bt = self.REQUEST.SESSION['browserType'] |
|
if bt['staticHTML']: |
|
return |
|
if bt['isN4']: |
|
f = 'zpt/zogilib_divsN4.zpt' |
|
else: |
|
f = 'zpt/zogilib_divs.zpt' |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self) |
|
return pt() |
|
|
|
|
|
def option_js(self): |
|
"""javascript""" |
|
return sendFile(self, 'js/option.js', 'text/plain') |
|
|
|
def dl_lib_js(self): |
|
"""javascript""" |
|
return sendFile(self, 'js/dllib.js', 'text/plain') |
|
|
|
def js_lib_js(self): |
|
"""javascript""" |
|
return sendFile(self, 'js/baselib.js', 'text/plain') |
|
|
|
def optionwindow(self): |
|
"""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: |
|
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) |
|
|
|
return pt() |
|
|
|
def mark1(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/mark1.gif', 'image/gif') |
|
|
|
def mark2(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/mark2.gif', 'image/gif') |
|
|
|
def mark3(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/mark3.gif', 'image/gif') |
|
|
|
def mark4(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/mark4.gif', 'image/gif') |
|
|
|
def mark5(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/mark5.gif', 'image/gif') |
|
|
|
def mark6(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/mark6.gif', 'image/gif') |
|
|
|
def mark7(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/mark7.gif', 'image/gif') |
|
|
|
def mark8(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/mark8.gif', 'image/gif') |
|
|
|
def corner1(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/olinks.gif', 'image/gif') |
|
|
|
def corner2(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/orechts.gif', 'image/gif') |
|
|
|
def corner3(self): |
|
"""mark image""" |
|
return sendFile(self, 'images/ulinks.gif', 'image/gif') |
|
|
|
def corner4(self): |
|
"""mark image""" |
|
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() |
self.checkQuery() |
bt = self.REQUEST.SESSION['browserType'] |
tp = "main_template" |
tp = "zogiLibMainTemplate" |
|
|
|
if hasattr(self, tp): |
|
pt = getattr(self, tp) |
|
else: |
|
tpt = self.layout |
tpt = self.layout |
|
|
if bt['staticHTML']: |
if not hasattr(self, 'template'): |
tpt = "static" |
# create template folder if it doesn't exist |
|
print "no template folder" |
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self) |
self.manage_addFolder('template') |
|
|
|
print "template!" |
|
pt = getattr(self.template, 'main_'+tpt) |
return pt() |
return pt() |
|
|
|
def checkQuery(self): |
|
"""make shure that the query has been saved""" |
|
if not self.REQUEST.has_key('dlParams'): |
|
self.storeQuery() |
|
if not self.REQUEST.SESSION.has_key('browserType'): |
|
bt = browserCheck(self) |
|
self.REQUEST.SESSION.set('browserType', bt) |
|
|
def storeQuery(self, more = None): |
def storeQuery(self, more=None, withpt=False): |
"""storeQuery in session""" |
"""parse query parameters into a hash in REQUEST""" |
dlParams = {} |
params = {} |
for fm in self.REQUEST.form.keys(): |
for fm in self.REQUEST.form.keys(): |
dlParams[fm] = self.REQUEST.form[fm] |
params[fm] = self.REQUEST.form[fm] |
# look for more |
# look for more |
if more: |
if more: |
for fm in more.split('&'): |
for fm in more.split('&'): |
try: |
try: |
pv = fm.split('=') |
pv = fm.split('=') |
dlParams[pv[0]] = pv[1] |
params[pv[0]] = pv[1] |
except: |
except: |
pass |
pass |
|
|
# parse digilib mode parameter |
# parse digilib mode parameter |
if 'mo' in dlParams: |
if 'mo' in params: |
if len(dlParams['mo']) > 0: |
if len(params['mo']) > 0: |
modes=dlParams['mo'].split(',') |
modes=params['mo'].split(',') |
else: |
|
modes=[] |
|
|
|
wid = self.getWID() |
|
self.REQUEST.set('wid', wid) |
|
self.setSubSession('dlQuery', dlParams) |
|
self.setSubSession('dlModes', modes) |
|
self.setSubSession('dlInfo', self.getDLInfo()) |
|
if not self.REQUEST.SESSION.has_key('browserType'): |
|
self.REQUEST.SESSION['browserType'] = browserCheck(self) |
|
|
|
return |
|
|
|
def checkQuery(self): |
|
"""check if the query has been stored""" |
|
if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) : |
|
print "ZOGILIB: have to store query!!" |
|
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: |
else: |
url += self.basePath |
modes = []; |
# should end with "/" |
|
if len(url) > 0 and url[-1] != '/': |
|
url += '/' |
|
return url |
|
|
|
def zogilibAction(self, action, otherbase=None, wid=None): |
self.REQUEST.set('dlParams', params) |
"""returns a URL with zogilib path, action and wid""" |
self.REQUEST.set('dlModes', modes) |
url = self.zogilibPath(otherbase) |
|
url += action |
|
if wid: |
|
url += '?wid=' + wid |
|
else: |
|
url += '?wid=' + self.getWID() |
|
return url |
|
|
|
def getSubSession(self, key, default=None): |
# trigger get pt (from dlInfo) if requested |
"""returns an element from a session with a wid""" |
if withpt: |
wid = self.getWID() |
pt = self.getPT() |
return self.REQUEST.SESSION.get(key+'_'+wid, default) |
|
|
return params |
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, default=None): |
"""returns parameter""" |
"""returns parameter or default""" |
|
self.checkQuery() |
|
dlParams = self.REQUEST.get('dlParams') |
try: |
try: |
return self.getSubSession('dlQuery').get(param) |
return dlParams[param] |
except: |
except: |
return |
return default |
|
|
def setDLParam(self, param, value): |
def setDLParam(self, param, value): |
"""sets parameter""" |
"""sets parameter""" |
dlParams = self.getSubSession('dlQuery') |
self.checkQuery() |
#try: |
dlParams = self.REQUEST.get('dlParams') |
dlParams[param] = value |
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.getSubSession('dlQuery') |
self.checkQuery() |
|
dlParams = self.REQUEST.get('dlParams') |
# save modes |
# save modes |
modes = self.getSubSession('dlModes') |
modes = self.REQUEST.get('dlModes') |
|
if modes: |
dlParams['mo'] = string.join(modes, ',') |
dlParams['mo'] = string.join(modes, ',') |
# assemble query string |
# assemble query string |
ret = "" |
ret = "" |
Line 603 class zogiLib(Folder):
|
Line 549 class zogiLib(Folder):
|
# 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""" |
|
|
Line 622 class zogiLib(Folder):
|
Line 567 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: |
Line 655 class zogiLib(Folder):
|
Line 596 class zogiLib(Folder):
|
# s += "_" + self.getDLParam('pn') |
# s += "_" + self.getDLParam('pn') |
return s |
return s |
|
|
def setStaticHTML(self, static=True): |
def getPN(self): |
"""sets the preference to static HTML""" |
"""pagenums""" |
self.checkQuery() |
pn = int(self.getDLParam('pn', 1)) |
self.REQUEST.SESSION['browserType']['staticHTML'] = static |
return pn |
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.getSubSession('dlInfo') |
pt = self.getDLParam('pt', None) |
if di: |
if pt is None: |
return int(di['pt']) |
# get pt from dlInfo |
else: |
if self.REQUEST.has_key('dlInfo'): |
return 1 |
info = self.REQUEST.get('dlInfo') |
|
else: |
def getPN(self): |
info = self.getDLInfo() |
"""Pagenum""" |
self.REQUEST.set('dlInfo', info) |
pn = self.getDLParam('pn') |
pt = int(info.get('pt', 1)) |
try: |
self.setDLParam('pt', pt) |
return int(pn) |
return int(pt) |
except: |
|
return 1 |
|
|
|
def getBiggerWS(self): |
|
"""ws+1""" |
|
ws = self.getDLParam('ws') |
|
try: |
|
return float(ws)+0.5 |
|
except: |
|
return 1.5 |
|
|
|
def getSmallerWS(self): |
|
"""ws-1""" |
|
ws=self.getDLParam('ws') |
|
try: |
|
return max(float(ws)-0.5, 1) |
|
except: |
|
return 1 |
|
|
|
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""" |
wid = self.getWID() |
return (mode in self.REQUEST.get('dlModes')) |
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 872 class zogiLib(Folder):
|
Line 788 class zogiLib(Folder):
|
self.setDLParam('mk', None) |
self.setDLParam('mk', None) |
return self.display() |
return self.display() |
|
|
def dl_Unmark(self): |
|
"""action to remove last mark""" |
|
mk = self.getDLParam('mk') |
|
if mk: |
|
marks = mk.split(',') |
|
marks.pop() |
|
mk = string.join(marks, ',') |
|
self.setDLParam('mk', mk) |
|
return self.display() |
|
|
|
def dl_db(self,db): |
def dl_db(self,db): |
"""set db""" |
"""set db""" |
self.setDLParam('db',db) |
self.setDLParam('db',db) |