1:
2: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
3: from Products.PageTemplates.PageTemplate import PageTemplate
4: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
5: from OFS.Image import Image
6: from webdav.common import rfc1123_date
7:
8: import xml.dom.minidom
9: from OFS.Folder import Folder
10: from xml_helpers import getText
11: import os
12: import re
13: import string
14: import urllib
15: from Globals import package_home
16:
17: def getString(self,key,default=''):
18: try:
19: return self.REQUEST[key]
20: except:
21: return default
22:
23:
24: class zogiLib_navTemplate(ZopePageTemplate):
25: """pageTemplate Objekt"""
26: meta_type="zogiLib_navTemplate"
27:
28: _default_content_fn = os.path.join(package_home(globals()),
29: 'zpt/zogiLib_NavTemplateDefault.zpt')
30:
31: manage_options=ZopePageTemplate.manage_options+(
32: {'label':'Copy to Filesystem','action':'copyContent'},
33: )
34:
35: def getPath(self):
36: """get path"""
37: return getPath(self,'thumbtemplate.templ')
38:
39:
40: def copyContent(self):
41: """copycontent to path"""
42:
43: return "copied to:"+copyContent(self,'thumbtemplate.templ')
44:
45:
46: def manage_addZogiLib_NavTemplateForm(self):
47: """Form for adding"""
48: pt=PageTemplateFile('Products/zogiLib/zpt/AddZogilib_NavTemplate.zpt').__of__(self)
49: return pt()
50:
51:
52:
53:
54: def manage_addZogiLib_NavTemplate(self, id,title=None, text=None,
55: REQUEST=None, submit=None):
56: "Add a Page Template with optional file content."
57:
58:
59: id = str(id)
60: if REQUEST is None:
61: self._setObject(id, zogilib_NavTemplate(id, text))
62: ob = getattr(self, id)
63:
64: if title:
65: ob.pt_setTitle(title)
66: return ob
67: else:
68: file = REQUEST.form.get('file')
69: headers = getattr(file, 'headers', None)
70: if headers is None or not file.filename:
71: zpt = zogilib_NavTemplate(id)
72: else:
73: zpt = zogilib_NavTemplate(id, file, headers.get('content_type'))
74:
75: self._setObject(id, zpt)
76: ob = getattr(self, id)
77:
78:
79: try:
80: u = self.DestinationURL()
81: except AttributeError:
82: u = REQUEST['URL1']
83:
84: if submit == " Add and Edit ":
85: u = "%s/%s" % (u, quote(id))
86: REQUEST.RESPONSE.redirect(u+'/manage_main')
87: return ''
88:
89:
90:
91: def readNavTemp(fileName):
92: """navtemp"""
93:
94:
95: if os.path.exists(fileName+"/index.meta"):
96: dom=xml.dom.minidom.parse(fileName+"/index.meta")
97: else:
98: return None
99:
100:
101: try:
102: navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)
103: except:
104: navTag=None
105: return navTag
106:
107: class zogiLib_mainTemplate(ZopePageTemplate):
108: """pageTemplate Objekt"""
109: meta_type="zogiLib_mainTemplate"
110:
111:
112: def __init__(self, id, text=None, content_type=None, version="book"):
113:
114: default_content_string="zpt/zogiLibMain_%s.zpt"%version
115: self._default_content_fn = os.path.join(package_home(globals()),default_content_string)
116: self.id = str(id)
117: self.ZBindings_edit(self._default_bindings)
118: if text is None:
119: text = open(self._default_content_fn).read()
120: self.pt_edit(text, content_type)
121:
122:
123: def manage_addZogiLibMainTemplateForm(self):
124: """Form for adding"""
125: pt=PageTemplateFile('Products/ECHO_content/zpt/AddOSAS_thumbTemplate.zpt').__of__(self)
126: return pt()
127:
128:
129:
130:
131: def manage_addZogiLibMainTemplate(self, id,title=None, text=None,
132: REQUEST=None, submit=None):
133: "Add a Page Template with optional file content."
134:
135:
136: id = str(id)
137: if REQUEST is None:
138: self._setObject(id, zogiLib_mainTemplate(id, text))
139: ob = getattr(self, id)
140:
141: if title:
142: ob.pt_setTitle(title)
143: return ob
144: else:
145: file = REQUEST.form.get('file')
146: headers = getattr(file, 'headers', None)
147: if headers is None or not file.filename:
148: zpt = zogiLib_mainTemplate(id)
149: else:
150: zpt = zogiLib_mainTemplate(id, file, headers.get('content_type'))
151:
152: self._setObject(id, zpt)
153: ob = getattr(self, id)
154:
155:
156: try:
157: u = self.DestinationURL()
158: except AttributeError:
159: u = REQUEST['URL1']
160:
161: if submit == " Add and Edit ":
162: u = "%s/%s" % (u, quote(id))
163: REQUEST.RESPONSE.redirect(u+'/manage_main')
164: return ''
165:
166:
167: class zogiImage(Image):
168: """einzelnes Image"""
169: meta_type="zogiImage"
170:
171:
172:
173: def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
174: """init"""
175: self.id=id
176: self.title=title
177: self.baseUrl=baseUrl
178: self.queryString=queryString
179: self.content_type=content_type
180: self.precondition=precondition
181:
182: def getData(self):
183: """getUrlData"""
184: return urllib.urlopen(self.baseUrl+self.queryString)
185:
186: def changeZogiImageForm(self):
187: """Main configuration"""
188: pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiImageForm.zpt').__of__(self)
189: return pt()
190:
191: def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):
192: """change it"""
193: self.title=title
194: self.baseUrl=baseUrl
195: self.queryString=queryString
196:
197: if RESPONSE is not None:
198: RESPONSE.redirect('manage_main')
199:
200:
201: manage_options=ZopePageTemplate.manage_options+(
202: {'label':'Main config','action':'changeZogiImageForm'},
203: )
204:
205:
206:
207:
208: def index_html(self, REQUEST, RESPONSE):
209: """
210: Modified version of OFS/Image.py
211:
212: The default view of the contents of a File or Image.
213:
214: Returns the contents of the file or image. Also, sets the
215: Content-Type HTTP header to the objects content type.
216: """
217:
218: # HTTP If-Modified-Since header handling.
219: header=REQUEST.get_header('If-Modified-Since', None)
220: if header is not None:
221: header=header.split( ';')[0]
222: # Some proxies seem to send invalid date strings for this
223: # header. If the date string is not valid, we ignore it
224: # rather than raise an error to be generally consistent
225: # with common servers such as Apache (which can usually
226: # understand the screwy date string as a lucky side effect
227: # of the way they parse it).
228: # This happens to be what RFC2616 tells us to do in the face of an
229: # invalid date.
230: try: mod_since=long(DateTime(header).timeTime())
231: except: mod_since=None
232: if mod_since is not None:
233: if self._p_mtime:
234: last_mod = long(self._p_mtime)
235: else:
236: last_mod = long(0)
237: if last_mod > 0 and last_mod <= mod_since:
238: # Set header values since apache caching will return Content-Length
239: # of 0 in response if size is not set here
240: RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))
241: RESPONSE.setHeader('Content-Type', self.content_type)
242: RESPONSE.setHeader('Content-Length', self.size)
243: RESPONSE.setHeader('Accept-Ranges', 'bytes')
244: self.ZCacheable_set(None)
245: RESPONSE.setStatus(304)
246: return ''
247:
248: if self.precondition and hasattr(self,self.precondition):
249: # Grab whatever precondition was defined and then
250: # execute it. The precondition will raise an exception
251: # if something violates its terms.
252: c=getattr(self,self.precondition)
253: if hasattr(c,'isDocTemp') and c.isDocTemp:
254: c(REQUEST['PARENTS'][1],REQUEST)
255: else:
256: c()
257:
258: # HTTP Range header handling
259: range = REQUEST.get_header('Range', None)
260: request_range = REQUEST.get_header('Request-Range', None)
261: if request_range is not None:
262: # Netscape 2 through 4 and MSIE 3 implement a draft version
263: # Later on, we need to serve a different mime-type as well.
264: range = request_range
265: if_range = REQUEST.get_header('If-Range', None)
266: if range is not None:
267: ranges = HTTPRangeSupport.parseRange(range)
268:
269: if if_range is not None:
270: # Only send ranges if the data isn't modified, otherwise send
271: # the whole object. Support both ETags and Last-Modified dates!
272: if len(if_range) > 1 and if_range[:2] == 'ts':
273: # ETag:
274: if if_range != self.http__etag():
275: # Modified, so send a normal response. We delete
276: # the ranges, which causes us to skip to the 200
277: # response.
278: ranges = None
279: else:
280: # Date
281: date = if_range.split( ';')[0]
282: try: mod_since=long(DateTime(date).timeTime())
283: except: mod_since=None
284: if mod_since is not None:
285: if self._p_mtime:
286: last_mod = long(self._p_mtime)
287: else:
288: last_mod = long(0)
289: if last_mod > mod_since:
290: # Modified, so send a normal response. We delete
291: # the ranges, which causes us to skip to the 200
292: # response.
293: ranges = None
294:
295: if ranges:
296: # Search for satisfiable ranges.
297: satisfiable = 0
298: for start, end in ranges:
299: if start < self.size:
300: satisfiable = 1
301: break
302:
303: if not satisfiable:
304: RESPONSE.setHeader('Content-Range',
305: 'bytes */%d' % self.size)
306: RESPONSE.setHeader('Accept-Ranges', 'bytes')
307: RESPONSE.setHeader('Last-Modified',
308: rfc1123_date(self._p_mtime))
309: RESPONSE.setHeader('Content-Type', self.content_type)
310: RESPONSE.setHeader('Content-Length', self.size)
311: RESPONSE.setStatus(416)
312: return ''
313:
314: ranges = HTTPRangeSupport.expandRanges(ranges, self.size)
315:
316: if len(ranges) == 1:
317: # Easy case, set extra header and return partial set.
318: start, end = ranges[0]
319: size = end - start
320:
321: RESPONSE.setHeader('Last-Modified',
322: rfc1123_date(self._p_mtime))
323: RESPONSE.setHeader('Content-Type', self.content_type)
324: RESPONSE.setHeader('Content-Length', size)
325: RESPONSE.setHeader('Accept-Ranges', 'bytes')
326: RESPONSE.setHeader('Content-Range',
327: 'bytes %d-%d/%d' % (start, end - 1, self.size))
328: RESPONSE.setStatus(206) # Partial content
329:
330: data = urllib.urlopen(self.baseUrl+self.queryString).read()
331: if type(data) is StringType:
332: return data[start:end]
333:
334: # Linked Pdata objects. Urgh.
335: pos = 0
336: while data is not None:
337: l = len(data.data)
338: pos = pos + l
339: if pos > start:
340: # We are within the range
341: lstart = l - (pos - start)
342:
343: if lstart < 0: lstart = 0
344:
345: # find the endpoint
346: if end <= pos:
347: lend = l - (pos - end)
348:
349: # Send and end transmission
350: RESPONSE.write(data[lstart:lend])
351: break
352:
353: # Not yet at the end, transmit what we have.
354: RESPONSE.write(data[lstart:])
355:
356: data = data.next
357:
358: return ''
359:
360: else:
361: boundary = choose_boundary()
362:
363: # Calculate the content length
364: size = (8 + len(boundary) + # End marker length
365: len(ranges) * ( # Constant lenght per set
366: 49 + len(boundary) + len(self.content_type) +
367: len('%d' % self.size)))
368: for start, end in ranges:
369: # Variable length per set
370: size = (size + len('%d%d' % (start, end - 1)) +
371: end - start)
372:
373:
374: # Some clients implement an earlier draft of the spec, they
375: # will only accept x-byteranges.
376: draftprefix = (request_range is not None) and 'x-' or ''
377:
378: RESPONSE.setHeader('Content-Length', size)
379: RESPONSE.setHeader('Accept-Ranges', 'bytes')
380: RESPONSE.setHeader('Last-Modified',
381: rfc1123_date(self._p_mtime))
382: RESPONSE.setHeader('Content-Type',
383: 'multipart/%sbyteranges; boundary=%s' % (
384: draftprefix, boundary))
385: RESPONSE.setStatus(206) # Partial content
386:
387: data = urllib.urlopen(self.baseUrl+self.queryString).read()
388: # The Pdata map allows us to jump into the Pdata chain
389: # arbitrarily during out-of-order range searching.
390: pdata_map = {}
391: pdata_map[0] = data
392:
393: for start, end in ranges:
394: RESPONSE.write('\r\n--%s\r\n' % boundary)
395: RESPONSE.write('Content-Type: %s\r\n' %
396: self.content_type)
397: RESPONSE.write(
398: 'Content-Range: bytes %d-%d/%d\r\n\r\n' % (
399: start, end - 1, self.size))
400:
401: if type(data) is StringType:
402: RESPONSE.write(data[start:end])
403:
404: else:
405: # Yippee. Linked Pdata objects. The following
406: # calculations allow us to fast-forward through the
407: # Pdata chain without a lot of dereferencing if we
408: # did the work already.
409: first_size = len(pdata_map[0].data)
410: if start < first_size:
411: closest_pos = 0
412: else:
413: closest_pos = (
414: ((start - first_size) >> 16 << 16) +
415: first_size)
416: pos = min(closest_pos, max(pdata_map.keys()))
417: data = pdata_map[pos]
418:
419: while data is not None:
420: l = len(data.data)
421: pos = pos + l
422: if pos > start:
423: # We are within the range
424: lstart = l - (pos - start)
425:
426: if lstart < 0: lstart = 0
427:
428: # find the endpoint
429: if end <= pos:
430: lend = l - (pos - end)
431:
432: # Send and loop to next range
433: RESPONSE.write(data[lstart:lend])
434: break
435:
436: # Not yet at the end, transmit what we have.
437: RESPONSE.write(data[lstart:])
438:
439: data = data.next
440: # Store a reference to a Pdata chain link so we
441: # don't have to deref during this request again.
442: pdata_map[pos] = data
443:
444: # Do not keep the link references around.
445: del pdata_map
446:
447: RESPONSE.write('\r\n--%s--\r\n' % boundary)
448: return ''
449:
450: RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))
451: RESPONSE.setHeader('Content-Type', self.content_type)
452: RESPONSE.setHeader('Content-Length', self.size)
453: RESPONSE.setHeader('Accept-Ranges', 'bytes')
454:
455: # Don't cache the data itself, but provide an opportunity
456: # for a cache manager to set response headers.
457: self.ZCacheable_set(None)
458:
459: data=urllib.urlopen(self.baseUrl+self.queryString).read()
460:
461: if type(data) is type(''):
462: RESPONSE.setBase(None)
463: return data
464:
465: while data is not None:
466: RESPONSE.write(data.data)
467: data=data.next
468:
469: return ''
470:
471:
472: def manage_addZogiImageForm(self):
473: """Form for adding"""
474: pt=PageTemplateFile('Products/zogiLib/zpt/addZogiImage.zpt').__of__(self)
475: return pt()
476:
477:
478: def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
479: """add dgilib"""
480: newObj=zogiImage(id,title,baseUrl, queryString)
481: self.Destination()._setObject(id,newObj)
482: if RESPONSE is not None:
483: RESPONSE.redirect('manage_main')
484:
485:
486:
487: class zogiLib(Folder):
488: """StandardElement"""
489:
490: meta_type="zogiLib"
491:
492: def getDlInfo(self):
493: """DLInfo"""
494: paramH={}
495: baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)
496:
497: url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])
498: dom=xml.dom.minidom.parse(url)
499: params=dom.getElementsByTagName('parameter')
500: for param in params:
501: paramH[param.getAttribute('name')]=param.getAttribute('value')
502: return paramH
503:
504: def getPageNumTotal(self):
505: """pagenums"""
506: return self.getDlInfo()['pt'].encode('utf-8')
507:
508:
509: def generateImageFolder(self):
510: """images ablegen"""
511: self.manage_addFolder('images')
512: pathName=os.path.join(package_home(globals()),'images')
513: for image in os.listdir(pathName):
514: try:
515:
516: fn=file(os.path.join(pathName,image))
517: self.images.manage_addImage(image,fn)
518: except:
519: print "ZOGILIB not imported:",image
520:
521:
522:
523:
524: def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):
525: """init"""
526:
527: self.id=id
528: self.title=title
529: self.digilibBaseUrl=digilibBaseUrl
530: self.localFileBase=localFileBase
531: #self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))
532: self._setObject('mainTemplate',zogiLib_mainTemplate(id='mainTemplate',version=version))
533: #self.generateImageFolder()
534:
535:
536: manage_options = Folder.manage_options+(
537: {'label':'Main Config','action':'changeZogiLibForm'},
538: )
539:
540: def option_js(self):
541: """option_js"""
542: ret="""
543: function setDLParam(e) {
544: var s;
545: if (document.all) {
546: s=e.srcElement;
547: } else {
548: s=e.target;
549: }
550: if (window.opener) {
551: window.opener.setParameter(s.name, s.value);
552: window.opener.display(9);
553: } else {
554: setParameter(s.name, s.value);
555: display(9);
556: }
557: }"""
558: return ret
559:
560:
561: def navigation_js(self):
562: """Javascript"""
563: fileName = os.path.join(package_home(globals()),'js/js_lib.js')
564: js = file(fileName).read()
565: fileName = os.path.join(package_home(globals()),'js/dl_lib.js')
566: js += file(fileName).read()
567: return js
568:
569:
570:
571: def generateTopJavaScript(self):
572: """generate script"""
573: ret="""
574: var baseUrl = '%s'; """% self.REQUEST['URL0']
575: ret+="""
576: newParameter('fn', '', 1);
577: newParameter('pn', '1', 1);
578: newParameter('ws', '1.0', 1);
579: newParameter('mo', '', 1);
580: newParameter('mk', '', 3);
581: newParameter('wx', '0.0', 2);
582: newParameter('wy', '0.0', 2);
583: newParameter('ww', '1.0', 2);
584: newParameter('wh', '1.0', 2);
585: newParameter('pt', '0', 9);
586: newParameter('brgt', '0.0', 1);
587: newParameter('cont', '0.0', 1);
588: newParameter('rot', '0.0', 1);
589: newParameter('rgba', '', 1);
590: newParameter('rgbm', '', 1);
591: newParameter('ddpix', '', 9);
592: newParameter('ddpiy', '', 9);
593: var picsize = new Size(100, 100);
594: document.id='digilib';
595:
596: """
597: return ret
598:
599:
600: def generateScalerImg(self,requestString):
601: """generate Scaler IMG Tag"""
602: retStr=self.digilibBaseUrl+requestString
603: jS="""<script type="text/javascript">var ps = bestPicSize('scaler');
604: document.write('<img id="pic" src="%s&dw='+ps.width+'&dh='+ps.height+'" />')
605: </script>"""%retStr
606: return jS
607:
608:
609: def mark1(self):
610: """mark image"""
611: fileName = os.path.join(package_home(globals()),'images/mark1.gif')
612: return file(fileName).read()
613:
614: def mark2(self):
615: """mark image"""
616: fileName = os.path.join(package_home(globals()),'images/mark2.gif')
617: return file(fileName).read()
618:
619: def mark3(self):
620: """mark image"""
621: fileName = os.path.join(package_home(globals()),'images/mark3.gif')
622: return file(fileName).read()
623:
624: def mark4(self):
625: """mark image"""
626: fileName = os.path.join(package_home(globals()),'images/mark4.gif')
627: return file(fileName).read()
628:
629: def mark5(self):
630: """mark image"""
631: fileName = os.path.join(package_home(globals()),'images/mark5.gif')
632: return file(fileName).read()
633:
634: def mark6(self):
635: """mark image"""
636: fileName = os.path.join(package_home(globals()),'images/mark6.gif')
637: return file(fileName).read()
638:
639: def mark7(self):
640: """mark image"""
641: fileName = os.path.join(package_home(globals()),'images/mark7.gif')
642: return file(fileName).read()
643:
644: def mark8(self):
645: """mark image"""
646: fileName = os.path.join(package_home(globals()),'images/mark8.gif')
647: return file(fileName).read()
648:
649: def corner1(self):
650: """mark image"""
651: fileName = os.path.join(package_home(globals()),'images/olinks.gif')
652: return file(fileName).read()
653:
654: def corner2(self):
655: """mark image"""
656: fileName = os.path.join(package_home(globals()),'images/orechts.gif')
657: return file(fileName).read()
658:
659: def corner3(self):
660: """mark image"""
661: fileName = os.path.join(package_home(globals()),'images/ulinks.gif')
662: return file(fileName).read()
663:
664: def corner4(self):
665: """mark image"""
666: fileName = os.path.join(package_home(globals()),'images/urechts.gif')
667: return file(fileName).read()
668:
669:
670:
671: def changeZogiLibForm(self):
672: """Main configuration"""
673: pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)
674: return pt()
675:
676: def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):
677: """change it"""
678: self.title=title
679: self.digilibBaseUrl=digilibBaseUrl
680: self.localFileBase=localFileBase
681:
682: if RESPONSE is not None:
683: RESPONSE.redirect('manage_main')
684:
685:
686: def nav_html(self,fileName):
687: """navigations frame"""
688: ## currently not in use
689: # suche nach index.meta mit zogilib thumb info
690:
691: templ=readNavTemp(self.localFileBase+"/"+fileName)
692: if not templ:
693: templ=readNavTemp(self.localFileBase+"/"+fileName.split("/")[0])
694: if not templ:
695: return self.topTemplate.document_src()
696:
697: return urllib.urlopen(templ).read()
698:
699:
700: def index_html(self):
701: """main action"""
702:
703: #pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_image.zpt').__of__(self)
704: #return pt()
705: return self.mainTemplate()
706:
707: def storeQuery(self):
708: """storeQuery in session"""
709: self.REQUEST.SESSION['query']={}
710: for fm in self.REQUEST.form.keys():
711: self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]
712:
713: self.REQUEST.SESSION['dlInfo']=self.getDlInfo()
714:
715: def getParam(self,param):
716: """Gebe Parameter aus"""
717: try:
718: return self.REQUEST.SESSION['query'][param]
719: except:
720: return None
721:
722: def getPageNum(self):
723: """PAgenum"""
724: pn=self.getParam('pn')
725: if pn:
726: return pn
727: else:
728: return 1
729:
730: def biggerWS(self):
731: """ws+1"""
732: ws=self.getParam('ws')
733: if ws:
734: return int(ws)+1
735: else:
736: return 2
737:
738: def options(self):
739: """showoptions"""
740: pt=PageTemplateFile('Products/zogiLib/zpt/optionwindow.zpt').__of__(self)
741: return pt()
742:
743:
744: def smallerWS(self):
745: """ws-11"""
746: ws=self.getParam('ws')
747: if ws:
748: if int(ws)==1:
749: return 1
750: else:
751: return int(ws)-1
752: else:
753: return 1
754:
755:
756: def setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
757: """setze Parameter"""
758: ret=""
759:
760: if brgt:
761: self.REQUEST.SESSION['query']['brgt']=brgt
762:
763: if cont:
764: self.REQUEST.SESSION['query']['cont']=cont
765:
766: if pn:
767: self.REQUEST.SESSION['query']['pn']=pn
768:
769: if ws:
770: self.REQUEST.SESSION['query']['ws']=ws
771:
772: if rot:
773: self.REQUEST.SESSION['query']['rot']=rot
774:
775: for param in self.REQUEST.SESSION['query'].keys():
776:
777: ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"
778:
779: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)
780:
781:
782: def mirrorPage(self,mi):
783: """mirror"""
784: ret=""
785: try:
786: splitted=self.REQUEST.SESSION['query']['mo'].split(',')
787: except:
788: splitted=[]
789:
790: if mi=="h":
791:
792: if 'hmir' in splitted:
793: splitted.remove('hmir')
794: else:
795: splitted.append('hmir')
796:
797: if mi=="v":
798:
799: if 'vmir' in splitted:
800: splitted.remove('vmir')
801: else:
802: splitted.append('vmir')
803:
804:
805: self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")
806:
807:
808:
809:
810: for param in self.REQUEST.SESSION['query'].keys():
811:
812: ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"
813:
814: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)
815:
816: def decode(self,strR):
817: """decode &"""
818:
819: return re.sub('\&','\&',strR)
820:
821: def wholePage(self):
822: """zoom out"""
823: ret=""
824:
825: self.REQUEST.SESSION['query']['ww']=1
826: self.REQUEST.SESSION['query']['wh']=1
827: self.REQUEST.SESSION['query']['wx']=0
828: self.REQUEST.SESSION['query']['wy']=0
829:
830: for param in self.REQUEST.SESSION['query'].keys():
831:
832: ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"
833:
834: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)
835:
836: def prevPage(self,pn=None):
837: """next page"""
838: ret=""
839:
840: if pn and pn>0:
841: pn=str(int(pn)-1)
842:
843:
844: self.REQUEST.form['pn']=pn
845:
846: for param in self.REQUEST.form.keys():
847:
848: ret+=param+"="+str(self.REQUEST.form[param])+"&"
849:
850: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)
851:
852: def firstPage(self):
853: """erste Seite"""
854: return self.setParam(pn="1")
855:
856: def lastPage(self):
857: """letzte Seite"""
858:
859:
860: def nextPage(self,pn=None):
861: """next page"""
862: ret=""
863:
864: try:
865: pn=str(int(pn)+1)
866: except:
867: pn=str(2)
868:
869: self.REQUEST.form['pn']=pn
870:
871: for param in self.REQUEST.form.keys():
872: ret+=param+"="+str(self.REQUEST.form[param])+"&"
873:
874: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)
875:
876: def generateDivs(self):
877: """generate divs"""
878: pt=PageTemplateFile('Products/zogiLib/zpt/zogilib_divs').__of__(self)
879: return pt()
880:
881: #divFileName=os.path.join(package_home(globals()),'zpt/zogilib_divs.zpt')
882: #return open(divFileName).read()
883:
884: def manage_addZogiLibForm(self):
885: """interface for adding zogilib"""
886: pt=PageTemplateFile('Products/zogiLib/zpt/addZogiLibForm').__of__(self)
887: return pt()
888:
889: def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",RESPONSE=None):
890: """add dgilib"""
891: newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version)
892: self.Destination()._setObject(id,newObj)
893: if RESPONSE is not None:
894: RESPONSE.redirect('manage_main')
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