1: from AccessControl import ClassSecurityInfo
2: from Globals import package_home
3: from OFS.Folder import Folder
4: from OFS.Image import Image
5: from OFS.Image import File
6: from OFS.SimpleItem import SimpleItem
7: from Products.PageTemplates.PageTemplate import PageTemplate
8: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
9: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
10: from types import *
11: from Globals import package_home, ImageFile
12: from xml_helpers import getUniqueElementText,getText
13: import cgi
14: import os
15: import random
16: import re
17: import string
18: import urllib
19: import xml.dom.minidom
20:
21: ZOGIVERSION = "0.10.3b ROC 13.7.2006"
22:
23: def cropf(f):
24: """returns a float with reduced precision"""
25: return float(int(f * 10000)/10000.0)
26:
27:
28: def browserCheck(self):
29: """check the browsers request to find out the browser type"""
30: bt = {}
31: ua = self.REQUEST.get_header("HTTP_USER_AGENT")
32: bt['ua'] = ua
33: bt['isIE'] = False
34: bt['isN4'] = False
35: if string.find(ua, 'MSIE') > -1:
36: bt['isIE'] = True
37: else:
38: bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
39:
40: try:
41: nav = ua[string.find(ua, '('):]
42: ie = string.split(nav, "; ")[1]
43: if string.find(ie, "MSIE") > -1:
44: bt['versIE'] = string.split(ie, " ")[1]
45: except: pass
46:
47: bt['isMac'] = string.find(ua, 'Macintosh') > -1
48: bt['isWin'] = string.find(ua, 'Windows') > -1
49: bt['isIEWin'] = bt['isIE'] and bt['isWin']
50: bt['isIEMac'] = bt['isIE'] and bt['isMac']
51: bt['staticHTML'] = False
52:
53: return bt
54:
55:
56: class zogiImage(SimpleItem):
57: """einzelnes Image"""
58: meta_type="zogiImage"
59:
60: manage_options=(
61: {'label':'Main config','action':'changeZogiImageForm'},
62: )+SimpleItem.manage_options
63:
64:
65: def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
66: """init"""
67: self.id=id
68: self.title=title
69: if baseUrl:
70: self.baseUrl=baseUrl
71: else:
72: self.baseUrl="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?"
73:
74: self.queryString=queryString
75: self.content_type=content_type
76: self.precondition=precondition
77:
78: #def getData(self):
79: # """getUrlData"""
80: # return urllib.urlopen(self.baseUrl+self.queryString)
81:
82: changeZogiImageForm = PageTemplateFile('zpt/changeZogiImageForm.zpt', globals())
83:
84: def index_html(self, REQUEST, RESPONSE):
85: """service the request by redirecting to digilib server"""
86: # use status 307 = moved temporarily
87: RESPONSE.redirect(self.baseUrl+self.queryString, status=307)
88: return ''
89:
90:
91: def rescale(self,width=None,height=None):
92: """andere parameter im querystring"""
93: qs=cgi.parse_qs(self.queryString)
94: for x in qs.keys():
95: if type(qs[x]) is ListType:
96: qs[x]=qs[x][0]
97:
98: if width:
99: qs['dw']=width
100: if height:
101: qs['dh']=height
102:
103: qsneu=urllib.urlencode(qs)
104: self.queryString=qsneu
105: return "done"
106:
107:
108: def setWithDigilibURL(self,digilibUrl):
109: """take all parameters from digilib URL string"""
110: base = re.match('(.*?/Scaler\?)(.*)', digilibUrl)
111: if base is not None:
112: params = base.group(2).split('&')
113: newparams = []
114: # filter out the parameters we want
115: for p in params:
116: (key, val) = p.split('=')
117: if key in ['fn','pn','dw','dh','ww','wh','wx','wy','mo']:
118: newparams.append(p)
119: # set the new parameters
120: if len(newparams) > 1:
121: self.baseUrl = base.group(1)
122: self.queryString = '&'.join(newparams)
123: return True
124:
125: return False
126:
127:
128: def changeZogiImage(self,title,baseUrl, queryString, digilibUrl=None, RESPONSE=None):
129: """change it"""
130: self.title=title
131: self.baseUrl=baseUrl
132: self.queryString=queryString
133: if digilibUrl is not None and len(digilibUrl) > 0:
134: self.setWithDigilibURL(digilibUrl)
135:
136: if RESPONSE is not None:
137: RESPONSE.redirect('manage_main')
138:
139:
140: def manage_addZogiImageForm(self):
141: """Form for adding"""
142: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
143: return pt()
144:
145:
146: def manage_addZogiImage(self,id,title,baseUrl,queryString,digilibUrl=None,RESPONSE=None):
147: """add zogiimage"""
148: newObj=zogiImage(id,title,baseUrl, queryString)
149: self.Destination()._setObject(id,newObj)
150: if digilibUrl is not None and len(digilibUrl) > 0:
151: newObj.setWithDigilibURL(digilibUrl)
152: if RESPONSE is not None:
153: RESPONSE.redirect('manage_main')
154:
155:
156:
157: class zogiLib(Folder):
158: """digilib frontend with ZOPE"""
159:
160: meta_type="zogiLib"
161: #xxxx
162: security=ClassSecurityInfo()
163:
164: manage_options = Folder.manage_options+(
165: {'label':'Main Config','action':'changeZogiLibForm'},
166: )
167:
168: def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
169: """init"""
170:
171: self.id = id
172: self.title = title
173: self.dlServerURL = dlServerURL
174: self.basePath = basePath
175: self.layout = layout
176: self.dlTarget = dlTarget
177:
178: if dlToolbarBaseURL:
179: self.dlToolbarBaseURL = dlToolbarBaseURL
180: else:
181: self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
182:
183: self.manage_addFolder('template')
184:
185:
186: # form templates
187: main_book = PageTemplateFile('zpt/main_book', globals())
188: main_image = PageTemplateFile('zpt/main_image', globals())
189: main_metaData = PageTemplateFile('zpt/main_metadata', globals())
190: #main_static = PageTemplateFile('zpt/main_static', globals())
191: options = PageTemplateFile('zpt/options', globals())
192: changeForm = PageTemplateFile('zpt/changeForm', globals())
193:
194: # display templates
195: aux_divs = PageTemplateFile('zpt/aux_divs', globals())
196: #aux_divsN4 = PageTemplateFile('zpt/aux_divsN4', globals())
197: img_div = PageTemplateFile('zpt/img_div', globals())
198:
199: # javascripts
200: head_js = PageTemplateFile('zpt/head_js', globals())
201: jslib_js = PageTemplateFile('js/baselib.js', globals())
202: dllib_js = PageTemplateFile('js/dllib.js', globals())
203:
204: # graphic files
205: arr_right = ImageFile('images/right.gif', globals())
206: arr_left = ImageFile('images/left.gif', globals())
207: arr_up = ImageFile('images/up.gif', globals())
208: arr_down = ImageFile('images/down.gif', globals())
209: mark1 = ImageFile('images/mark1.gif', globals())
210: mark2 = ImageFile('images/mark2.gif', globals())
211: mark3 = ImageFile('images/mark3.gif', globals())
212: mark4 = ImageFile('images/mark4.gif', globals())
213: mark5 = ImageFile('images/mark5.gif', globals())
214: mark6 = ImageFile('images/mark6.gif', globals())
215: mark7 = ImageFile('images/mark7.gif', globals())
216: mark8 = ImageFile('images/mark8.gif', globals())
217: corner1 = ImageFile('images/olinks.gif', globals())
218: corner2 = ImageFile('images/orechts.gif', globals())
219: corner3 = ImageFile('images/ulinks.gif', globals())
220: corner4 = ImageFile('images/urechts.gif', globals())
221:
222:
223: security.declareProtected('View','getLayout')
224: def getLayout(self):
225: """get Layout"""
226: return self.layout
227:
228: def version(self):
229: """version information"""
230: return ZOGIVERSION
231:
232: def getContextStatic(self):
233: """get all the contexts which go to static pages"""
234:
235: try:
236: dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
237: contexts=dom.getElementsByTagName("context")
238:
239: ret=[]
240: for context in contexts:
241: name=getUniqueElementText(context.getElementsByTagName("name"))
242:
243: link=getUniqueElementText(context.getElementsByTagName("link"))
244: if name or link:
245: ret.append((name,link))
246: return ret
247: except:
248: return []
249:
250: def getContextDatabases(self):
251: """get all dynamic contexts"""
252: try:
253: dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
254: contexts=dom.getElementsByTagName("context")
255: ret=[]
256: for context in contexts:
257: metaDataLinks=context.getElementsByTagName("meta-datalink")
258: for metaDataLink in metaDataLinks:
259: db=metaDataLink.getAttribute("db")
260: link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
261: if db:
262: ret.append((db,link))
263: metaDataLinks=context.getElementsByTagName("meta-baselink")
264:
265: for metaDataLink in metaDataLinks:
266: db=metaDataLink.getAttribute("db")
267: link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
268: if db:
269: ret.append((db,link))
270:
271: return ret
272: except:
273:
274: return []
275:
276:
277: def formatHTML(self,url,label=None,viewUrl=None):
278:
279: sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
280: ret=""
281: #print label
282: if label:
283: ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
284: for set in sets:
285: ret+="<table>"
286: for node in set.childNodes:
287: if hasattr(node,'tagName'):
288: tag=node.tagName
289: label=node.getAttribute("label")
290: if not label:
291: label=tag
292: text=getText(node.childNodes)
293: ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text)
294: ret+="</table>"
295: return ret
296:
297:
298: def getMetaData(self):
299: """getMetaData"""
300: try:
301: dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
302: except:
303: return "error metadata"
304:
305: contexts=dom.getElementsByTagName("context")
306: ret=[]
307: db=self.getDLParam("db")
308: ob=self.getDLParam("object")
309:
310: fn=self.getDLParam("fn")
311: pn=self.getDLParam("pn")
312: if not fn:
313: fn=""
314: if not pn:
315: pn=""
316: if not ob:
317: ob=""
318:
319: for context in contexts:
320: metaDataLinks=context.getElementsByTagName("meta-datalink")
321: for metaDataLink in metaDataLinks:
322:
323: if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1):
324:
325: link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
326: label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
327: url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
328:
329: return self.formatHTML(link,label,url)
330:
331: metaDataLinks=context.getElementsByTagName("meta-baselink")
332:
333: for metaDataLink in metaDataLinks:
334:
335: if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1):
336:
337: link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
338: label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
339: url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
340:
341: return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
342: return ret
343:
344:
345: def getDLInfo(self):
346: """get DLInfo from digilib server"""
347: paramH={}
348: baseUrl=self.getDLBaseUrl()+"/dlInfo-xml.jsp"
349: #print "getdlinfo: ", baseUrl
350: try:
351: url=urllib.urlopen(baseUrl+'?'+self.getAllDLParams())
352: dom=xml.dom.minidom.parse(url)
353: params=dom.getElementsByTagName('parameter')
354: for param in params:
355: paramH[param.getAttribute('name')]=param.getAttribute('value')
356: return paramH
357: except:
358: return {}
359:
360:
361: def zogilibPath(self, otherbase=None):
362: """returns an URL to the zogiLib instance"""
363: url = self.REQUEST['URL1']
364: # should end with "/"
365: if len(url) > 0 and url[-1] != '/':
366: url += '/'
367: if type(otherbase) is str:
368: url += otherbase
369: else:
370: url += self.basePath
371: # should still end with "/"
372: if len(url) > 0 and url[-1] != '/':
373: url += '/'
374: return url
375:
376: def zogilibAction(self, action, otherbase=None):
377: """returns a URL with zogilib path and action"""
378: url = self.zogilibPath(otherbase)
379: url += action
380: url += '?' + self.getAllDLParams();
381: return url
382:
383: def getDLBaseUrl(self):
384: """returns digilib base URL (sans servlet path)"""
385: if self.dlServerURL[-1] == '?':
386: # full Servlet URL -- remove last part
387: si = self.dlServerURL.rindex('/servlet/')
388: if si > 0:
389: return self.dlServerURL[:si]
390: else:
391: # no servlet part :-(
392: return "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
393: else:
394: return self.dlServerURL
395:
396:
397: def getScalerUrl(self,requestString=""):
398: """send scaler url"""
399: if self.dlServerURL[-1] == '?':
400: # full Servlet URL
401: return self.dlServerURL + requestString
402: else:
403: return self.dlServerURL+'/servlet/Scaler?'+requestString
404:
405: def scaledImage(self,requestString=None):
406: """scaled Image"""
407:
408: if not requestString:
409: requestString=self.REQUEST['QUERY_STRING']
410:
411: self.REQUEST.RESPONSE.redirect(self.getScalerUrl(requestString))
412:
413: return True
414:
415:
416: def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500, options=None):
417: """generate Scaler IMG Tag"""
418: self.checkQuery()
419: bt = self.getBrowserType()
420: # override with parameters from session
421: if self.REQUEST.SESSION.has_key('scalerDiv'):
422: (requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']
423: # if not explicitly defined take normal request
424: if not requestString:
425: requestString = self.getAllDLParams()
426: url = self.getScalerUrl(requestString=requestString)
427: # take insets from options if present
428: if options is not None:
429: side = options.get('side', side)
430: bottom = options.get('bottom', bottom)
431: # construct bottom and side insets
432: b_par = ""
433: s_par = ""
434: if (bottom != 0) or (side != 0):
435: b_par = "-" + str(int(bottom))
436: s_par = "-" + str(int(side))
437: tag = ""
438: if bt['staticHTML']:
439: tag += '<div id="scaler"><img id="pic" src="%s&dw=%i&dh=%i" /></div>'%(url, int(width-side), int(height-bottom))
440: else:
441: if bt['isN4']:
442: # N4 needs layers
443: tag += '<ilayer id="scaler">'
444: else:
445: tag += '<div id="scaler">'
446: tag += '<script type="text/javascript">'
447: tag += "var ps = bestPicSize(getElement('scaler'));"
448: # write img tag with javascript
449: tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\');'%(url, s_par, b_par)
450: tag += '</script>'
451: if bt['isN4']:
452: tag += '</ilayer>'
453: else:
454: tag += '</div>'
455: return tag
456:
457: def createScalerDiv(self, requestString = None, bottom = 0, side = 0, width=500, height=500):
458: """generate scaler img and table with navigation arrows"""
459: self.checkQuery()
460: if requestString != None or bottom != 0 or side != 0:
461: self.REQUEST.SESSION['scalerDiv'] = (requestString, bottom, side, width, height)
462: else:
463: if self.REQUEST.SESSION.has_key('scalerDiv'):
464: # make shure to remove unused parameter
465: del self.REQUEST.SESSION['scalerDiv']
466:
467: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
468: return pt()
469:
470: def index_html(self):
471: """main action"""
472: self.checkQuery()
473: tp = "main_template"
474: tpt = self.layout
475:
476: if not hasattr(self, 'template'):
477: # create template folder if it doesn't exist
478: print "no template folder -- creating"
479: self.manage_addFolder('template')
480:
481: pt = getattr(self.template, 'main_'+tpt)
482: return pt()
483:
484: def checkQuery(self):
485: """make shure that the query has been saved"""
486: if not self.REQUEST.has_key('dlParams'):
487: self.storeQuery()
488:
489: def storeQuery(self, more=None, withpt=False):
490: """parse query parameters into a hash in REQUEST"""
491: params = {}
492: for fm in self.REQUEST.form.keys():
493: params[fm] = self.REQUEST.form[fm]
494: # look for more
495: if more:
496: for fm in more.split('&'):
497: try:
498: pv = fm.split('=')
499: params[pv[0]] = pv[1]
500: except:
501: pass
502:
503: # parse digilib mode parameter
504: if 'mo' in params:
505: if len(params['mo']) > 0:
506: modes=params['mo'].split(',')
507: else:
508: modes = [];
509:
510: self.REQUEST.set('dlParams', params)
511: self.REQUEST.set('dlModes', modes)
512:
513: # trigger get pt (from dlInfo) if requested
514: if withpt:
515: pt = self.getPT()
516:
517: return params
518:
519:
520: def getDLParam(self, param, default=None):
521: """returns parameter or default"""
522: self.checkQuery()
523: dlParams = self.REQUEST.get('dlParams')
524: try:
525: return dlParams[param]
526: except:
527: return default
528:
529: def setDLParam(self, param, value):
530: """sets parameter"""
531: self.checkQuery()
532: dlParams = self.REQUEST.get('dlParams')
533: dlParams[param] = value
534: return
535:
536: def getAllDLParams(self):
537: """parameter string for digilib"""
538: self.checkQuery()
539: dlParams = self.REQUEST.get('dlParams')
540: # save modes
541: modes = self.REQUEST.get('dlModes')
542: if modes:
543: dlParams['mo'] = string.join(modes, ',')
544: # assemble query string
545: ret = ""
546: for param in dlParams.keys():
547: if dlParams[param] is None: continue
548: val = str(dlParams[param])
549: if val != "":
550: ret += param + "=" + val + "&"
551:
552: # omit trailing "&"
553: return ret.rstrip('&')
554:
555: def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
556: """setze Parameter"""
557:
558: self.setDLParam('brgt', brgt)
559: self.setDLParam('cont', cont)
560: self.setDLParam('ws', ws)
561: self.setDLParam('rot', rot)
562:
563: if pn:
564: # unmark
565: self.setDLParam('mk', None)
566: self.setDLParam('pn', pn)
567:
568: return self.display()
569:
570: def getBrowserType(self):
571: """get browser type object"""
572: if self.REQUEST.SESSION.has_key('browserType'):
573: return self.REQUEST.SESSION['browserType']
574: else:
575: bt = browserCheck(self)
576: self.REQUEST.SESSION.set('browserType', bt)
577: return bt
578:
579:
580: def display(self):
581: """(re)display page"""
582: params = self.getAllDLParams()
583:
584: if self.basePath:
585: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
586: else:
587: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
588:
589: def getMetaFileName(self):
590: url=self.dlServerURL+'/dlContext-xml.jsp?'+self.getAllDLParams()
591: return urlbase
592:
593: def getToolbarPageURL(self):
594: """returns a toolbar-enabled page URL"""
595: url=self.dlToolbarBaseURL+self.getAllDLParams()
596: return url
597:
598: def getDLTarget(self):
599: """returns dlTarget"""
600: self.checkQuery()
601: s = self.dlTarget
602: if (s is None) or (s == ""):
603: # s = ""
604: s = 'dl'
605: if self.getDLParam('fn'):
606: s += "_" + self.getDLParam('fn')
607: if self.getDLParam('pn'):
608: s += "_" + self.getDLParam('pn')
609:
610: return s
611:
612: def getPN(self):
613: """pagenumber"""
614: pn = int(self.getDLParam('pn', 1))
615: return pn
616:
617: def getPT(self):
618: """number of total pages"""
619: pt = self.getDLParam('pt', None)
620: if pt is None:
621: # get pt from dlInfo
622: if self.REQUEST.has_key('dlInfo'):
623: info = self.REQUEST.get('dlInfo')
624: else:
625: info = self.getDLInfo()
626: self.REQUEST.set('dlInfo', info)
627: pt = int(info.get('pt', 1))
628: self.setDLParam('pt', pt)
629: return int(pt)
630:
631: def hasMode(self, mode):
632: """returns if mode is in the diglib mo parameter"""
633: return (mode in self.REQUEST.get('dlModes'))
634:
635: def hasNextPage(self):
636: """returns if there is a next page"""
637: pn = self.getPN()
638: pt = self.getPT()
639: return (pn < pt)
640:
641: def hasPrevPage(self):
642: """returns if there is a previous page"""
643: pn = self.getPN()
644: return (pn > 1)
645:
646: def canMoveLeft(self):
647: """returns if its possible to move left"""
648: wx = float(self.getDLParam('wx') or 0)
649: return (wx > 0)
650:
651: def canMoveRight(self):
652: """returns if its possible to move right"""
653: wx = float(self.getDLParam('wx') or 0)
654: ww = float(self.getDLParam('ww') or 1)
655: return (wx + ww < 1)
656:
657: def canMoveUp(self):
658: """returns if its possible to move up"""
659: wy = float(self.getDLParam('wy') or 0)
660: return (wy > 0)
661:
662: def canMoveDown(self):
663: """returns if its possible to move down"""
664: wy = float(self.getDLParam('wy') or 0)
665: wh = float(self.getDLParam('wh') or 1)
666: return (wy + wh < 1)
667:
668:
669: def dl_StaticHTML(self):
670: """set rendering to static HTML"""
671: self.checkQuery()
672: self.getBrowserType()['staticHTML'] = True
673: return self.display()
674:
675: def dl_DynamicHTML(self):
676: """set rendering to dynamic HTML"""
677: self.checkQuery()
678: self.getBrowserType()['staticHTML'] = False
679: return self.display()
680:
681: def dl_HMirror(self):
682: """mirror action"""
683: modes = self.getSubSession('dlModes')
684: if 'hmir' in modes:
685: modes.remove('hmir')
686: else:
687: modes.append('hmir')
688:
689: return self.display()
690:
691: def dl_VMirror(self):
692: """mirror action"""
693: modes = self.getSubSession('dlModes')
694: if 'vmir' in modes:
695: modes.remove('vmir')
696: else:
697: modes.append('vmir')
698:
699: return self.display()
700:
701: def dl_Zoom(self, z):
702: """general zoom action"""
703: ww1 = float(self.getDLParam('ww') or 1)
704: wh1 = float(self.getDLParam('wh') or 1)
705: wx = float(self.getDLParam('wx') or 0)
706: wy = float(self.getDLParam('wy') or 0)
707: ww2 = ww1 * z
708: wh2 = wh1 * z
709: wx += (ww1 - ww2) / 2
710: wy += (wh1 - wh2) / 2
711: ww2 = max(min(ww2, 1), 0)
712: wh2 = max(min(wh2, 1), 0)
713: wx = max(min(wx, 1), 0)
714: wy = max(min(wy, 1), 0)
715: self.setDLParam('ww', cropf(ww2))
716: self.setDLParam('wh', cropf(wh2))
717: self.setDLParam('wx', cropf(wx))
718: self.setDLParam('wy', cropf(wy))
719: return self.display()
720:
721: def dl_ZoomIn(self):
722: """zoom in action"""
723: z = 0.7071
724: return self.dl_Zoom(z)
725:
726: def dl_ZoomOut(self):
727: """zoom out action"""
728: z = 1.4142
729: return self.dl_Zoom(z)
730:
731: def dl_Move(self, dx, dy):
732: """general move action"""
733: ww = float(self.getDLParam('ww') or 1)
734: wh = float(self.getDLParam('wh') or 1)
735: wx = float(self.getDLParam('wx') or 0)
736: wy = float(self.getDLParam('wy') or 0)
737: wx += dx * 0.5 * ww
738: wy += dy * 0.5 * wh
739: wx = max(min(wx, 1), 0)
740: wy = max(min(wy, 1), 0)
741: self.setDLParam('wx', cropf(wx))
742: self.setDLParam('wy', cropf(wy))
743: return self.display()
744:
745: def dl_MoveLeft(self):
746: """move left action"""
747: return self.dl_Move(-1, 0)
748:
749: def dl_MoveRight(self):
750: """move left action"""
751: return self.dl_Move(1, 0)
752:
753: def dl_MoveUp(self):
754: """move left action"""
755: return self.dl_Move(0, -1)
756:
757: def dl_MoveDown(self):
758: """move left action"""
759: return self.dl_Move(0, 1)
760:
761: def dl_WholePage(self):
762: """zoom out action"""
763: self.setDLParam('ww', 1)
764: self.setDLParam('wh', 1)
765: self.setDLParam('wx', 0)
766: self.setDLParam('wy', 0)
767: return self.display()
768:
769: def dl_PrevPage(self):
770: """next page action"""
771: pn = self.getPN() - 1
772: if pn < 1:
773: pn = 1
774: self.setDLParam('pn', pn)
775: # unmark
776: self.setDLParam('mk', None)
777: return self.display()
778:
779: def dl_NextPage(self):
780: """next page action"""
781: pn = self.getPN() + 1
782: pt = self.getPT()
783: if pn > pt:
784: pn = pt
785: self.setDLParam('pn', pn)
786: # unmark
787: self.setDLParam('mk', None)
788: return self.display()
789:
790: def dl_FirstPage(self):
791: """first page action"""
792: self.setDLParam('pn', 1)
793: # unmark
794: self.setDLParam('mk', None)
795: return self.display()
796:
797: def dl_LastPage(self):
798: """last page action"""
799: self.setDLParam('pn', self.getPT())
800: # unmark
801: self.setDLParam('mk', None)
802: return self.display()
803:
804: def dl_db(self,db):
805: """set db"""
806: self.setDLParam('db',db)
807: self.display()
808:
809: def changeZogiLibForm(self):
810: """Main configuration"""
811: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
812: return pt()
813:
814: def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
815: """change it"""
816: self.title=title
817: self.dlServerURL=dlServerURL
818: self.basePath = basePath
819: self.layout=version
820: self.dlTarget = dlTarget
821:
822: if dlToolbarBaseURL:
823: self.dlToolbarBaseURL = dlToolbarBaseURL
824: else:
825: self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
826:
827: if RESPONSE is not None:
828: RESPONSE.redirect('manage_main')
829:
830:
831:
832: ##
833: ## odds and ends
834: ##
835:
836: def repairZogilib(self, obj=None):
837: """change stuff that broke on upgrading"""
838:
839: msg = ""
840:
841: if not obj:
842: obj = self.getPhysicalRoot()
843:
844: print "starting in ", obj
845:
846: entries=obj.ZopeFind(obj,obj_metatypes=['zogiLib'],search_sub=1)
847:
848: for entry in entries:
849: print " found ", entry
850: #
851: # replace digilibBaseUrl by dlServerURL
852: if hasattr(entry[1], 'digilibBaseUrl'):
853: msg += " fixing digilibBaseUrl in "+entry[0]+"\n"
854: entry[1].dlServerURL = re.sub('/servlet/Scaler\?','',entry[1].digilibBaseUrl)
855: del entry[1].digilibBaseUrl
856:
857: #
858: # add dlToolbarBaseURL
859: if not hasattr(entry[1], 'dlToolbarBaseURL'):
860: msg += " fixing dlToolbarBaseURL in "+entry[0]+"\n"
861: entry[1].dlToolbarBaseURL = entry[1].dlServerURL + "/digimage.jsp?"
862:
863: return msg+"\n\nfixed all zogilib instances in: "+obj.title
864:
865:
866: def manage_addZogiLibForm(self):
867: """interface for adding zogilib"""
868: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
869: return pt()
870:
871: def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
872: """add dgilib"""
873: newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
874: self.Destination()._setObject(id,newObj)
875: if RESPONSE is not None:
876: RESPONSE.redirect('manage_main')
877:
878:
879: class zogiLibPageTemplate(ZopePageTemplate):
880: """pageTemplate Objekt"""
881: meta_type="zogiLib_pageTemplate"
882:
883:
884: ## def __init__(self, id, text=None, contentType=None):
885: ## self.id = str(id)
886: ## self.ZBindings_edit(self._default_bindings)
887: ## if text is None:
888: ## text = open(self._default_cont).read()
889: ## self.pt_edit(text, contentType)
890:
891: def manage_addZogiLibPageTemplateForm(self):
892: """Form for adding"""
893: pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
894: return pt()
895:
896: def manage_addZogiLibPageTemplate(self, title=None, layout=None, text=None,
897: REQUEST=None, submit=None):
898: "Add a Page Template with optional file content."
899:
900: if not layout: layout = "book"
901: id = 'main_%s'%layout
902: self._setObject(id, zogiLibPageTemplate(id))
903: ob = getattr(self, id)
904: ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/main_%s.zpt'%layout)).read(),None)
905: if title:
906: ob.pt_setTitle(title)
907: try:
908: url = self.DestinationURL()
909: except AttributeError:
910: url = REQUEST['URL1']
911:
912: url = "%s/%s" % (url, urllib.quote(id))
913: REQUEST.RESPONSE.redirect(url+'/manage_main')
914: return ''
915:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to zogiLib.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / zogiLib