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