[BACK]Return to zogiLib.py CVS log [TXT] [DIR] Up to [Repository] / zogiLib

Diff for /zogiLib/zogiLib.py between versions 1.20 and 1.58

version 1.20, 2004/06/02 19:01:36 version 1.58, 2005/10/11 20:06:05
Line 1 Line 1
   from OFS.SimpleItem import SimpleItem
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from OFS.Image import Image  from OFS.Image import Image
 from webdav.common import rfc1123_date  from AccessControl import ClassSecurityInfo
   
 import xml.dom.minidom  import xml.dom.minidom
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from xml_helpers import getText  from xml_helpers import getUniqueElementText,getText
 import os  import os
 import re  import re
 import string  import string
 import urllib  import urllib
   from types import *
   import random
   import cgi
 from Globals import package_home  from Globals import package_home
   
 def getString(self,key,default=''):  ZOGIVERSION = "0.9.15b DW:22.2.2005"
     try:  
         return self.REQUEST[key]  def cropf(f):
     except:      """returns a float with reduced precision"""
         return default      return float(int(f * 10000)/10000.0)
   
   
 def sendFile(self, filename, type):  def sendFile(self, filename, type):
     """sends an object or a local file (in the product) as response"""      """sends an object or a local file (from the product) as response"""
     paths = filename.split('/')      paths = filename.split('/')
     object = self      object = self
     # look for an object called filename      # look for an object called filename
Line 41  def sendFile(self, filename, type): Line 44  def sendFile(self, filename, type):
     self.REQUEST.RESPONSE.write(file(fn).read())      self.REQUEST.RESPONSE.write(file(fn).read())
     return      return
   
 class BrowserCheck:  def browserCheck(self):
     """check the browsers request to find out the browser type"""      """check the browsers request to find out the browser type"""
           bt = {}
     def __init__(self, zope):      ua = self.REQUEST.get_header("HTTP_USER_AGENT")
     self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")      bt['ua'] = ua
     self.isIE = string.find(self.ua, 'MSIE') > -1      bt['isIE'] = False
     self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and not self.isIE      bt['isN4'] = False
     self.nav = self.ua[string.find(self.ua, '('):]      if string.find(ua, 'MSIE') > -1:
     ie = string.split(self.nav, "; ")[1]          bt['isIE'] = True
     if string.find(ie, "MSIE") > -1:  
         self.versIE = string.split(ie, " ")[1]  
     self.isMac = string.find(self.ua, 'Macintosh') > -1  
     self.isWin = string.find(self.ua, 'Windows') > -1  
     self.isIEWin = self.isIE and self.isWin  
     self.isIEMac = self.isIE and self.isMac  
   
   
 def manage_addZogiLibMainTemplateForm(self):  
     """Form for adding"""  
     #FIXME:???  
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/AddOSAS_thumbTemplate.zpt')).__of__(self)  
     return pt()  
   
   
   
   
 def manage_addZogiLibMainTemplate(self, id,title=None, text=None,  
                            REQUEST=None, submit=None):  
     "Add a Page Template with optional file content."  
     #FIXME:???  
     id = str(id)  
     if REQUEST is None:  
         self._setObject(id, zogiLib_mainTemplate(id, text))  
         ob = getattr(self, id)  
          
         if title:  
             ob.pt_setTitle(title)  
         return ob  
     else:      else:
         file = REQUEST.form.get('file')          bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
         headers = getattr(file, 'headers', None)  
         if headers is None or not file.filename:  
             zpt = zogiLib_mainTemplate(id)  
         else:  
             zpt = zogiLib_mainTemplate(id, file, headers.get('content_type'))  
   
         self._setObject(id, zpt)  
         ob = getattr(self, id)  
   
   
         try:          try:
             u = self.DestinationURL()          nav = ua[string.find(ua, '('):]
         except AttributeError:          ie = string.split(nav, "; ")[1]
             u = REQUEST['URL1']          if string.find(ie, "MSIE") > -1:
               bt['versIE'] = string.split(ie, " ")[1]
       except: pass
   
         if submit == " Add and Edit ":      bt['isMac'] = string.find(ua, 'Macintosh') > -1
             u = "%s/%s" % (u, quote(id))      bt['isWin'] = string.find(ua, 'Windows') > -1
         REQUEST.RESPONSE.redirect(u+'/manage_main')      bt['isIEWin'] = bt['isIE'] and bt['isWin']
     return ''      bt['isIEMac'] = bt['isIE'] and bt['isMac']
       bt['staticHTML'] = False
   
       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 115  class zogiImage(Image): Line 85  class zogiImage(Image):
         """init"""          """init"""
         self.id=id          self.id=id
         self.title=title          self.title=title
           if baseUrl:
         self.baseUrl=baseUrl          self.baseUrl=baseUrl
           else:
               self.baseUrl="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?"
               
         self.queryString=queryString          self.queryString=queryString
         self.content_type=content_type          self.content_type=content_type
         self.precondition=precondition          self.precondition=precondition
   
     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 138  class zogiImage(Image): Line 112  class zogiImage(Image):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
           
     def index_html(self, REQUEST, RESPONSE):      def index_html(self, REQUEST, RESPONSE):
         """          """service the request by redirecting to digilib server"""
         Modified version of OFS/Image.py          RESPONSE.redirect(self.baseUrl+self.queryString)
           return ''
                   
         The default view of the contents of a File or Image.      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"
   
         Returns the contents of the file or image.  Also, sets the  def manage_addZogiImageForm(self):
         Content-Type HTTP header to the objects content type.      """Form for adding"""
         """      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
       return pt()
         # HTTP If-Modified-Since header handling.  
         header=REQUEST.get_header('If-Modified-Since', None)  
         if header is not None:  
             header=header.split( ';')[0]  
             # Some proxies seem to send invalid date strings for this  
             # header. If the date string is not valid, we ignore it  
             # rather than raise an error to be generally consistent  
             # with common servers such as Apache (which can usually  
             # understand the screwy date string as a lucky side effect  
             # of the way they parse it).  
             # This happens to be what RFC2616 tells us to do in the face of an  
             # invalid date.  
             try:    mod_since=long(DateTime(header).timeTime())  
             except: mod_since=None  
             if mod_since is not None:  
                 if self._p_mtime:  
                     last_mod = long(self._p_mtime)  
                 else:  
                     last_mod = long(0)  
                 if last_mod > 0 and last_mod <= mod_since:  
                     # Set header values since apache caching will return Content-Length  
                     # of 0 in response if size is not set here  
                     RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', self.size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     self.ZCacheable_set(None)  
                     RESPONSE.setStatus(304)  
                     return ''  
   
         if self.precondition and hasattr(self,self.precondition):  
             # Grab whatever precondition was defined and then  
             # execute it.  The precondition will raise an exception  
             # if something violates its terms.  
             c=getattr(self,self.precondition)  
             if hasattr(c,'isDocTemp') and c.isDocTemp:  
                 c(REQUEST['PARENTS'][1],REQUEST)  
             else:  
                 c()  
   
         # HTTP Range header handling  
         range = REQUEST.get_header('Range', None)  
         request_range = REQUEST.get_header('Request-Range', None)  
         if request_range is not None:  
             # Netscape 2 through 4 and MSIE 3 implement a draft version  
             # Later on, we need to serve a different mime-type as well.  
             range = request_range  
         if_range = REQUEST.get_header('If-Range', None)  
         if range is not None:  
             ranges = HTTPRangeSupport.parseRange(range)  
   
             if if_range is not None:  
                 # Only send ranges if the data isn't modified, otherwise send  
                 # the whole object. Support both ETags and Last-Modified dates!  
                 if len(if_range) > 1 and if_range[:2] == 'ts':  
                     # ETag:  
                     if if_range != self.http__etag():  
                         # Modified, so send a normal response. We delete  
                         # the ranges, which causes us to skip to the 200  
                         # response.  
                         ranges = None  
                 else:  
                     # Date  
                     date = if_range.split( ';')[0]  
                     try: mod_since=long(DateTime(date).timeTime())  
                     except: mod_since=None  
                     if mod_since is not None:  
                         if self._p_mtime:  
                             last_mod = long(self._p_mtime)  
                         else:  
                             last_mod = long(0)  
                         if last_mod > mod_since:  
                             # Modified, so send a normal response. We delete  
                             # the ranges, which causes us to skip to the 200  
                             # response.  
                             ranges = None  
   
             if ranges:  
                 # Search for satisfiable ranges.  
                 satisfiable = 0  
                 for start, end in ranges:  
                     if start < self.size:  
                         satisfiable = 1  
                         break  
   
                 if not satisfiable:  def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
                     RESPONSE.setHeader('Content-Range',      """add zogiimage"""
                         'bytes */%d' % self.size)      newObj=zogiImage(id,title,baseUrl, queryString)
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')      self.Destination()._setObject(id,newObj)
                     RESPONSE.setHeader('Last-Modified',      if RESPONSE is not None:
                         rfc1123_date(self._p_mtime))          RESPONSE.redirect('manage_main')
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', self.size)  
                     RESPONSE.setStatus(416)  
                     return ''  
   
                 ranges = HTTPRangeSupport.expandRanges(ranges, self.size)  
                                                                   
                 if len(ranges) == 1:  
                     # Easy case, set extra header and return partial set.  
                     start, end = ranges[0]  
                     size = end - start  
   
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Content-Range',  
                         'bytes %d-%d/%d' % (start, end - 1, self.size))  
                     RESPONSE.setStatus(206) # Partial content  
   
                     data = urllib.urlopen(self.baseUrl+self.queryString).read()  
                     if type(data) is StringType:  
                         return data[start:end]  
   
                     # Linked Pdata objects. Urgh.  
                     pos = 0  
                     while data is not None:  
                         l = len(data.data)  
                         pos = pos + l  
                         if pos > start:  
                             # We are within the range  
                             lstart = l - (pos - start)  
   
                             if lstart < 0: lstart = 0  
   
                             # find the endpoint  
                             if end <= pos:  
                                 lend = l - (pos - end)  
   
                                 # Send and end transmission  class zogiLib(Folder):
                                 RESPONSE.write(data[lstart:lend])      """digilib frontend with ZOPE"""
                                 break  
       meta_type="zogiLib"
       #xxxx
       security=ClassSecurityInfo()
       
       manage_options = Folder.manage_options+(
               {'label':'Main Config','action':'changeZogiLibForm'},
               )
   
                             # Not yet at the end, transmit what we have.      def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
                             RESPONSE.write(data[lstart:])          """init"""
   
                         data = data.next          self.id=id
           self.title=title
           self.dlServerURL = dlServerURL
           self.basePath=basePath
           self.layout=layout
           self.dlTarget = dlTarget
   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
       security.declareProtected('View','getLayout')
       def getLayout(self):
           """get Layout"""
           return self.layout
       
       def version(self):
           """version information"""
           return ZOGIVERSION
   
                     return ''      def getContextStatic(self):
           """get all the contexts which go to static pages"""
   
                 else:          try:
                     boundary = choose_boundary()              dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
               contexts=dom.getElementsByTagName("context")
   
                     # Calculate the content length              ret=[]
                     size = (8 + len(boundary) + # End marker length              for context in contexts:
                         len(ranges) * (         # Constant lenght per set                  name=getUniqueElementText(context.getElementsByTagName("name"))
                             49 + len(boundary) + len(self.content_type) +  
                             len('%d' % self.size)))                  link=getUniqueElementText(context.getElementsByTagName("link"))
                     for start, end in ranges:                  if name or link:
                         # Variable length per set                      ret.append((name,link))
                         size = (size + len('%d%d' % (start, end - 1)) +              return ret
                             end - start)          except:
               return []
   
                     # Some clients implement an earlier draft of the spec, they  
                     # will only accept x-byteranges.  
                     draftprefix = (request_range is not None) and 'x-' or ''  
   
                     RESPONSE.setHeader('Content-Length', size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type',  
                         'multipart/%sbyteranges; boundary=%s' % (  
                             draftprefix, boundary))  
                     RESPONSE.setStatus(206) # Partial content  
   
                     data = urllib.urlopen(self.baseUrl+self.queryString).read()  
                     # The Pdata map allows us to jump into the Pdata chain  
                     # arbitrarily during out-of-order range searching.  
                     pdata_map = {}  
                     pdata_map[0] = data  
   
                     for start, end in ranges:  
                         RESPONSE.write('\r\n--%s\r\n' % boundary)  
                         RESPONSE.write('Content-Type: %s\r\n' %  
                             self.content_type)  
                         RESPONSE.write(  
                             'Content-Range: bytes %d-%d/%d\r\n\r\n' % (  
                                 start, end - 1, self.size))  
   
                         if type(data) is StringType:  
                             RESPONSE.write(data[start:end])  
   
                         else:  
                             # Yippee. Linked Pdata objects. The following  
                             # calculations allow us to fast-forward through the  
                             # Pdata chain without a lot of dereferencing if we  
                             # did the work already.  
                             first_size = len(pdata_map[0].data)  
                             if start < first_size:  
                                 closest_pos = 0  
                             else:  
                                 closest_pos = (  
                                     ((start - first_size) >> 16 << 16) +  
                                     first_size)  
                             pos = min(closest_pos, max(pdata_map.keys()))  
                             data = pdata_map[pos]  
   
                             while data is not None:  
                                 l = len(data.data)  
                                 pos = pos + l  
                                 if pos > start:  
                                     # We are within the range  
                                     lstart = l - (pos - start)  
   
                                     if lstart < 0: lstart = 0  
   
                                     # find the endpoint  
                                     if end <= pos:  
                                         lend = l - (pos - end)  
   
                                         # Send and loop to next range      def getContextDatabases(self):
                                         RESPONSE.write(data[lstart:lend])          """get all dynamic contexts"""
                                         break          try:
               dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
               contexts=dom.getElementsByTagName("context")
               ret=[]
               for context in contexts:
                   metaDataLinks=context.getElementsByTagName("meta-datalink")
                   for metaDataLink in metaDataLinks:
                       db=metaDataLink.getAttribute("db")
                       link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
                       if db:
                           ret.append((db,link))
                   metaDataLinks=context.getElementsByTagName("meta-baselink")
   
                   for metaDataLink in metaDataLinks:
                       db=metaDataLink.getAttribute("db")
                       link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
                       if db:
                           ret.append((db,link))
   
                                     # Not yet at the end, transmit what we have.              return ret
                                     RESPONSE.write(data[lstart:])          except:
   
                                 data = data.next              return []
                                 # Store a reference to a Pdata chain link so we  
                                 # don't have to deref during this request again.  
                                 pdata_map[pos] = data  
   
                     # Do not keep the link references around.  
                     del pdata_map  
   
                     RESPONSE.write('\r\n--%s--\r\n' % boundary)      def formatHTML(self,url,label=None,viewUrl=None):
                     return ''  
   
         RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))          sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
         RESPONSE.setHeader('Content-Type', self.content_type)          ret=""
         RESPONSE.setHeader('Content-Length', self.size)          print label
         RESPONSE.setHeader('Accept-Ranges', 'bytes')          if label:
               ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
         # Don't cache the data itself, but provide an opportunity          for set in sets:
         # for a cache manager to set response headers.              ret+="<table>"
         self.ZCacheable_set(None)              for node in set.childNodes:
                   if hasattr(node,'tagName'):
         data=urllib.urlopen(self.baseUrl+self.queryString).read()                      tag=node.tagName
                               label=node.getAttribute("label")
         if type(data) is type(''):                       if not label:
             RESPONSE.setBase(None)                          label=tag
             return data                      text=getText(node.childNodes)
                       ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text)
         while data is not None:              ret+="</table>"
             RESPONSE.write(data.data)          return ret
             data=data.next  
   
         return ''  
   
       def getMetaData(self):
           """getMetaData"""
           try:
               dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
           except:
               return "error metadata"
   
 def manage_addZogiImageForm(self):          contexts=dom.getElementsByTagName("context")
     """Form for adding"""          ret=[]
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)          db=self.getDLParam("db")
     return pt()          ob=self.getDLParam("object")
   
           fn=self.getDLParam("fn")
           pn=self.getDLParam("pn")
           if not fn:
               fn=""
           if not pn:
               pn=""
           if not ob:
               ob=""
   
 def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):          for context in contexts:
     """add dgilib"""              metaDataLinks=context.getElementsByTagName("meta-datalink")
     newObj=zogiImage(id,title,baseUrl, queryString)              for metaDataLink in metaDataLinks:
     self.Destination()._setObject(id,newObj)  
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
                   if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1):
   
                       link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
                       label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
                       url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
   
 class zogiLib(Folder):                      return self.formatHTML(link,label,url)
     """StandardElement"""  
   
     meta_type="zogiLib"              metaDataLinks=context.getElementsByTagName("meta-baselink")
   
     manage_options = Folder.manage_options+(              for metaDataLink in metaDataLinks:
             {'label':'Main Config','action':'changeZogiLibForm'},  
             )  
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):                  if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1):
         """init"""  
   
         self.id=id                      link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
         self.title=title                      label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
         self.digilibBaseUrl=digilibBaseUrl                      url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
         self.localFileBase=localFileBase  
         self.layout=version                      return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
           return ret
   
   
     def getDLInfo(self):      def getDLInfo(self):
         """get DLInfo from digilib server"""          """get DLInfo from digilib server"""
         paramH={}          paramH={}
         baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)          baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
         try:          try:
             url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])              url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING'])
             dom=xml.dom.minidom.parse(url)              dom=xml.dom.minidom.parse(url)
             params=dom.getElementsByTagName('parameter')              params=dom.getElementsByTagName('parameter')
             for param in params:              for param in params:
                 paramH[param.getAttribute('name')]=param.getAttribute('value')                  paramH[param.getAttribute('name')]=param.getAttribute('value')
             return paramH              return paramH
         except:          except:
             return null              return {}
   
   
     def createHeadJS(self):      def createHeadJS(self):
         """generate all javascript tags for head"""          """generate all javascript tags for head"""
           self.checkQuery()
           bt = self.REQUEST.SESSION.get('browserType', {})
           if bt['staticHTML']:
               return
           
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
         return pt()          return pt()
   
     def createParamJS(self):      def createParamJS(self):
         """generate javascript for parameters only"""          """generate javascript for parameters only"""
           self.checkQuery()
           bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
   
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
         return pt()          return pt()
                   
                                                   
     def createScalerImg(self, requestString = None):      def getScalerUrl(self,requestString=None):
           """send scaler url"""
           if requestString:
               return self.dlServerURL+'/servlet/Scaler?'+requestString
           else:
               return self.dlServerURL+'/servlet/Scaler?'
       
       def scaledImage(self,requestString=None):
           """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):
         """generate Scaler IMG Tag"""          """generate Scaler IMG Tag"""
     self.checkQuery()      self.checkQuery()
     bt = self.REQUEST.SESSION['browserType']      bt = self.REQUEST.SESSION['browserType']
           # override with parameters from session
           if  self.REQUEST.SESSION.has_key('scalerDiv'):
               (requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']
           # if not explicitly defined take normal request
         if not requestString:          if not requestString:
             requestString = self.REQUEST.QUERY_STRING              requestString = self.getAllDLParams()
         url = self.digilibBaseUrl+requestString          url = self.dlServerURL+'/servlet/Scaler?'+requestString
           # construct bottom and side insets
           b_par = ""
           s_par = ""
           if (bottom != 0) or (side != 0):
               b_par = "-" + str(int(bottom))
               s_par = "-" + str(int(side))
         tag = ""          tag = ""
         if bt.isN4:          if bt['staticHTML']:
               tag += '<div id="scaler"><img id="pic" src="%s&dw=%i&dh=%i" /></div>'%(url, int(width-side), int(height-bottom))
           else:
               if bt['isN4']:
                   # N4 needs layers
             tag += '<ilayer id="scaler">'              tag += '<ilayer id="scaler">'
         else:          else:
             tag += '<div id="scaler">'              tag += '<div id="scaler">'
         tag += '<script type="text/javascript">'          tag += '<script type="text/javascript">'
         tag += "var ps = bestPicSize(getElement('scaler'));"          tag += "var ps = bestPicSize(getElement('scaler'));"
         tag += 'document.write(\'<img id="pic" src="%s&dw=\'+ps.width+\'&dh=\'+ps.height+\'" />\')'%url              # write img tag with javascript
               tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\');'%(url, s_par, b_par)
         tag += '</script>'          tag += '</script>'
         if bt.isN4:              if bt['isN4']:
             tag += '</ilayer>'              tag += '</ilayer>'
         else:          else:
             tag += '</div>'              tag += '</div>'
         return tag          return tag
   
       def createScalerDiv(self, requestString = None, bottom = 0, side = 0, width=500, height=500):
           """generate scaler img and table with navigation arrows"""
           self.checkQuery()
           if requestString != None or bottom != 0 or side != 0:
               self.REQUEST.SESSION['scalerDiv'] = (requestString, bottom, side, width, height)
           else:
               if self.REQUEST.SESSION.has_key('scalerDiv'):
                   # make shure to remove unused parameter
                   del self.REQUEST.SESSION['scalerDiv']
                   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
           return pt()
   
     def createAuxDiv(self):      def createAuxDiv(self):
         """generate other divs"""          """generate other divs"""
     self.checkQuery()      self.checkQuery()
     bt = self.REQUEST.SESSION['browserType']      bt = self.REQUEST.SESSION['browserType']
         if bt.isN4:          if bt['staticHTML']:
               return
           if bt['isN4']:
             f = 'zpt/zogilib_divsN4.zpt'              f = 'zpt/zogilib_divsN4.zpt'
         else:          else:
             f = 'zpt/zogilib_divs.zpt'              f = 'zpt/zogiLib_divs.zpt'
         pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self)
         return pt()          return pt()
   
   
     def option_js(self):      def option_js(self):
         """option_js"""          """javascript"""
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/option_js')).__of__(self)          return sendFile(self, 'js/option.js', 'text/plain')
         return pt()  
   
     def dl_lib_js(self):      def dl_lib_js(self):
         """javascript"""          """javascript"""
         return sendFile(self, 'js/dl_lib.js', 'text/plain')          return sendFile(self, 'js/dllib.js', 'text/plain')
   
     def js_lib_js(self):      def js_lib_js(self):
         """javascript"""          """javascript"""
         return sendFile(self, 'js/js_lib.js', 'text/plain')          return sendFile(self, 'js/baselib.js', 'text/plain')
   
     def optionwindow(self):      def optionwindow(self):
         """showoptions"""          """showoptions"""
           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)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
                   
         return pt()          return pt()
   
     def mark1(self):      def mark1(self):
Line 563  class zogiLib(Folder): Line 490  class zogiLib(Folder):
         """mark image"""          """mark image"""
         return sendFile(self, 'images/urechts.gif', 'image/gif')          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()
           bt = self.REQUEST.SESSION['browserType']
         tp = "zogiLibMainTemplate"          tp = "zogiLibMainTemplate"
           
         if hasattr(self, tp):          if hasattr(self, tp):
         pt = getattr(self, tp)          pt = getattr(self, tp)
         else:          else:
             pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%self.layout)).__of__(self)              tpt = self.layout
         return pt()  
   
               if bt['staticHTML']:
                   tpt = "static"
   
               pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)
   
     def storeQuery(self):          return pt()
   
   
       def storeQuery(self, more = None):
         """storeQuery in session"""          """storeQuery in session"""
         dlParams = {}          dlParams = {}
         for fm in self.REQUEST.form.keys():          for fm in self.REQUEST.form.keys():
             dlParams[fm] = self.REQUEST.form[fm]              dlParams[fm] = self.REQUEST.form[fm]
           # look for more
           if more:
               for fm in more.split('&'):
                   try:
                       pv = fm.split('=')
                       dlParams[pv[0]] = pv[1]
                   except:
                       pass
   
           # parse digilib mode parameter
         if 'mo' in dlParams:          if 'mo' in dlParams:
             if len(dlParams['mo']) > 0:              if len(dlParams['mo']) > 0:
                 modes=dlParams['mo'].split(',')                  modes=dlParams['mo'].split(',')
         else:          else:
             modes=[]              modes=[]
   
         self.REQUEST.SESSION['query'] = dlParams          wid = self.getWID()
         self.REQUEST.SESSION['dlModes'] = modes          self.REQUEST.set('wid', wid)
         self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()          self.setSubSession('dlQuery', dlParams)
         self.REQUEST.SESSION['browserType'] = BrowserCheck(self)          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):      def checkQuery(self):
     """check if the query has been stored"""      """check if the query has been stored"""
     if not (self.REQUEST.SESSION and 'query' in self.REQUEST.SESSION):          if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) :
         print "ZOGILIB: have to store query!!"          print "ZOGILIB: have to store query!!"
         storeQuery(self)              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:
               url += self.basePath
           # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
   
       def zogilibAction(self, action, otherbase=None, wid=None):
           """returns a URL with zogilib path, action and wid"""
           url = self.zogilibPath(otherbase)
           url += action
           if wid:
               url += '?wid=' + wid
           else:
               url += '?wid=' + self.getWID()
           return url
   
       def getSubSession(self, key, default=None):
           """returns an element from a session with a wid"""
           wid = self.getWID()
           return self.REQUEST.SESSION.get(key+'_'+wid, default)
   
       def setSubSession(self, key, value):
           """puts an element in a session with a wid"""
           wid = self.getWID()
           self.REQUEST.SESSION.set(key+'_'+wid, value)
           return
   
       def getWID(self):
           """returns a (new) window id"""
           wid = self.REQUEST.get('wid')
           if not wid:
               wid = 'digi_'+str(int(random.random()*10000))
               print "new WID:", wid
           return wid
                   
     def getDLParam(self,param):      def getDLParam(self, param, default=None):
         """returns parameter"""          """returns parameter or default"""
         try:          try:
             return self.REQUEST.SESSION['query'][param]              return self.getSubSession('dlQuery').get(param, default)
         except:          except:
             return None              return default
   
     def setDLParam(self, param, value):      def setDLParam(self, param, value):
         """sets parameter"""          """sets parameter"""
         self.REQUEST.SESSION['query'][param] = value          dlParams = self.getSubSession('dlQuery')
           #try:
           dlParams[param] = value
           #except:
           #    self.setSubSession('dlQuery', {param: value})
         return          return
   
     def getAllDLParams(self):      def getAllDLParams(self):
         """parameter string for digilib"""          """parameter string for digilib"""
         dlParams = self.REQUEST.SESSION['query']          dlParams = self.getSubSession('dlQuery')
         # save modes          # save modes
         modes = self.REQUEST.SESSION['dlModes']          modes = self.getSubSession('dlModes')
         dlParams['mo'] = string.join(modes, ',')          dlParams['mo'] = string.join(modes, ',')
         # assemble query string          # assemble query string
         ret = ""          ret = ""
         for param in dlParams.keys():          for param in dlParams.keys():
               if dlParams[param] is None: continue
             val = str(dlParams[param])              val = str(dlParams[param])
             if val != "":              if val != "":
                 ret += param + "=" + val + "&"                  ret += param + "=" + val + "&"
   
         # 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"""
         ret=""  
   
         if brgt:  
             self.setDLParam('brgt', brgt)              self.setDLParam('brgt', brgt)
   
         if cont:  
             self.setDLParam('cont', cont)              self.setDLParam('cont', cont)
           self.setDLParam('ws', ws)
           self.setDLParam('rot', rot)
   
         if pn:          if pn:
               # unmark
               self.setDLParam('mk', None)
             self.setDLParam('pn', pn)              self.setDLParam('pn', pn)
   
         if ws:  
             self.setDLParam('ws', ws)  
   
         if rot:  
             self.setDLParam('rot', rot)  
               
         return self.display()          return self.display()
   
   
     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:
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
           else:
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)          self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
   
       def getMetaFileName(self):
           url=self.dlServerURL+'/dlContext-xml.jsp?'+self.getAllDLParams()
           return urlbase
   
       def getToolbarPageURL(self):
           """returns a toolbar-enabled page URL"""
           url=self.dlToolbarBaseURL+self.getAllDLParams()
           return url
       
       def getDLTarget(self):
           """returns dlTarget"""
           self.checkQuery()
           s = self.dlTarget
           if s == None:
               s = ""
   #         s = 'dl'
   #         if self.getDLParam('fn'):
   #             s += "_" + self.getDLParam('fn')
   #         if self.getDLParam('pn'):
   #             s += "_" + self.getDLParam('pn')
           return s
   
       def setStaticHTML(self, static=True):
           """sets the preference to static HTML"""
           self.checkQuery()
           self.REQUEST.SESSION['browserType']['staticHTML'] = static
           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.REQUEST.SESSION['dlInfo']          di = self.getSubSession('dlInfo')
         if di:          if di:
             return int(di['pt'])              return int(di['pt'])
         else:          else:
Line 666  class zogiLib(Folder): Line 716  class zogiLib(Folder):
     def getPN(self):      def getPN(self):
         """Pagenum"""          """Pagenum"""
         pn = self.getDLParam('pn')          pn = self.getDLParam('pn')
         if pn:          try:
             return int(pn)              return int(pn)
         else:          except:
             return 1              return 1
   
     def getBiggerWS(self):      def getBiggerWS(self):
         """ws+1"""          """ws+1"""
         ws=self.getDLParam('ws')          ws=self.getDLParam('ws')
         if ws:          try:
             return int(ws)+1              return float(ws)+0.5
         else:          except:
             return 2              return 1.5
   
                   
     def getSmallerWS(self):      def getSmallerWS(self):
         """ws-1"""          """ws-1"""
         ws=self.getDLParam('ws')          ws=self.getDLParam('ws')
         if ws:          try:
             if int(ws)==1:              return max(float(ws)-0.5, 1)
                 return 1          except:
             else:  
                 return int(ws)-1  
         else:  
             return 1              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"""
         return (mode in self.REQUEST.SESSION['dlModes'])          wid = self.getWID()
           return (mode in self.REQUEST.SESSION['dlModes_'+wid])
   
     def hasNextPage(self):      def hasNextPage(self):
         """returns if there is a next page"""          """returns if there is a next page"""
Line 706  class zogiLib(Folder): Line 753  class zogiLib(Folder):
         pn = self.getPN()          pn = self.getPN()
         return (pn > 1)          return (pn > 1)
   
       def canMoveLeft(self):
           """returns if its possible to move left"""
           wx = float(self.getDLParam('wx') or 0)
           return (wx > 0)
   
       def canMoveRight(self):
           """returns if its possible to move right"""
           wx = float(self.getDLParam('wx') or 0)
           ww = float(self.getDLParam('ww') or 1)
           return (wx + ww < 1)
   
       def canMoveUp(self):
           """returns if its possible to move up"""
           wy = float(self.getDLParam('wy') or 0)
           return (wy > 0)
   
       def canMoveDown(self):
           """returns if its possible to move down"""
           wy = float(self.getDLParam('wy') or 0)
           wh = float(self.getDLParam('wh') or 1)
           return (wy + wh < 1)
   
   
       def dl_StaticHTML(self):
           """set rendering to static HTML"""
           self.checkQuery()
           self.REQUEST.SESSION['browserType']['staticHTML'] = True
           return self.display()
         
       def dl_DynamicHTML(self):
           """set rendering to dynamic HTML"""
           self.checkQuery()
           self.REQUEST.SESSION['browserType']['staticHTML'] = False
           return self.display()
                   
     def dl_HMirror(self):      def dl_HMirror(self):
         """mirror action"""          """mirror action"""
         modes = self.REQUEST.SESSION['dlModes']          modes = self.getSubSession('dlModes')
         if 'hmir' in modes:          if 'hmir' in modes:
             modes.remove('hmir')              modes.remove('hmir')
         else:          else:
Line 720  class zogiLib(Folder): Line 800  class zogiLib(Folder):
                 
     def dl_VMirror(self):      def dl_VMirror(self):
         """mirror action"""          """mirror action"""
         modes = self.REQUEST.SESSION['dlModes']          modes = self.getSubSession('dlModes')
         if 'vmir' in modes:          if 'vmir' in modes:
             modes.remove('vmir')              modes.remove('vmir')
         else:          else:
Line 728  class zogiLib(Folder): Line 808  class zogiLib(Folder):
   
         return self.display()          return self.display()
   
       def dl_Zoom(self, z):
           """general zoom action"""
           ww1 = float(self.getDLParam('ww') or 1)
           wh1 = float(self.getDLParam('wh') or 1)
           wx = float(self.getDLParam('wx') or 0)
           wy = float(self.getDLParam('wy') or 0)
           ww2 = ww1 * z
           wh2 = wh1 * z
           wx += (ww1 - ww2) / 2
           wy += (wh1 - wh2) / 2
           ww2 = max(min(ww2, 1), 0)
           wh2 = max(min(wh2, 1), 0)
           wx = max(min(wx, 1), 0)
           wy = max(min(wy, 1), 0)
           self.setDLParam('ww', cropf(ww2))
           self.setDLParam('wh', cropf(wh2))
           self.setDLParam('wx', cropf(wx))
           self.setDLParam('wy', cropf(wy))
           return self.display()
           
       def dl_ZoomIn(self):
           """zoom in action"""
           z = 0.7071
           return self.dl_Zoom(z)
   
       def dl_ZoomOut(self):
           """zoom out action"""
           z = 1.4142
           return self.dl_Zoom(z)
   
       def dl_Move(self, dx, dy):
           """general move action"""
           ww = float(self.getDLParam('ww') or 1)
           wh = float(self.getDLParam('wh') or 1)
           wx = float(self.getDLParam('wx') or 0)
           wy = float(self.getDLParam('wy') or 0)
           wx += dx * 0.5 * ww
           wy += dy * 0.5 * wh
           wx = max(min(wx, 1), 0)
           wy = max(min(wy, 1), 0)
           self.setDLParam('wx', cropf(wx))
           self.setDLParam('wy', cropf(wy))
           return self.display()
           
       def dl_MoveLeft(self):
           """move left action"""
           return self.dl_Move(-1, 0)
       
       def dl_MoveRight(self):
           """move left action"""
           return self.dl_Move(1, 0)
       
       def dl_MoveUp(self):
           """move left action"""
           return self.dl_Move(0, -1)
       
       def dl_MoveDown(self):
           """move left action"""
           return self.dl_Move(0, 1)
       
     def dl_WholePage(self):      def dl_WholePage(self):
         """zoom out action"""          """zoom out action"""
         self.setDLParam('ww', 1)          self.setDLParam('ww', 1)
Line 781  class zogiLib(Folder): Line 921  class zogiLib(Folder):
             self.setDLParam('mk', mk)              self.setDLParam('mk', mk)
         return self.display()          return self.display()
   
       def dl_db(self,db):
           """set db"""
           self.setDLParam('db',db)
           self.display()
   
     def changeZogiLibForm(self):      def changeZogiLibForm(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
         return pt()          return pt()
           
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase, version, RESPONSE=None):      def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
         """change it"""          """change it"""
         self.title=title          self.title=title
         self.digilibBaseUrl=digilibBaseUrl          self.dlServerURL=dlServerURL
         self.localFileBase=localFileBase          self.basePath = basePath
         self.layout=version          self.layout=version
           self.dlTarget = dlTarget
   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
                       
   
       ##
       ## odds and ends
       ##
   
       def repairZogilib(self, obj=None):
           """change stuff that broke on upgrading"""
   
           msg = ""
   
           if not obj:
               obj = self.getPhysicalRoot()
   
           print "starting in ", obj
           
           entries=obj.ZopeFind(obj,obj_metatypes=['zogiLib'],search_sub=1)
   
           for entry in entries:
               print "  found ", entry
               #
               # replace digilibBaseUrl by dlServerURL
               if hasattr(entry[1], 'digilibBaseUrl'):
                   msg += "  fixing digilibBaseUrl in "+entry[0]+"\n"
                   entry[1].dlServerURL = re.sub('/servlet/Scaler\?','',entry[1].digilibBaseUrl)
                   del entry[1].digilibBaseUrl
                   
               #
               # add dlToolbarBaseURL
               if not hasattr(entry[1], 'dlToolbarBaseURL'):
                   msg += "  fixing dlToolbarBaseURL in "+entry[0]+"\n"
                   entry[1].dlToolbarBaseURL = entry[1].dlServerURL + "/digimage.jsp?"
                   
           return msg+"\n\nfixed all zogilib instances in: "+obj.title
   
             
 def manage_addZogiLibForm(self):  def manage_addZogiLibForm(self):
     """interface for adding zogilib"""      """interface for adding zogilib"""
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
     return pt()      return pt()
   
 def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",RESPONSE=None):  def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
     """add dgilib"""      """add dgilib"""
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version)      newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
     self.Destination()._setObject(id,newObj)      self.Destination()._setObject(id,newObj)
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   class zogiLibPageTemplate(ZopePageTemplate):
       """pageTemplate Objekt"""
       meta_type="zogiLib_pageTemplate"
   
   
   ## def __init__(self, id, text=None, contentType=None):
   ##         self.id = str(id)
   ##         self.ZBindings_edit(self._default_bindings)
   ##         if text is None:
   ##             text = open(self._default_cont).read()
   ##         self.pt_edit(text, contentType)
   
   def manage_addZogiLibPageTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
       return pt()
   
   def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
   
       id = str(id)
       self._setObject(id, zogiLibPageTemplate(id))
       ob = getattr(self, id)
       if not layout: layout = "book"
       ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/zogiLibMain_%s.zpt'%layout)).read(),None)
       if title:
           ob.pt_setTitle(title)
       try:
           u = self.DestinationURL()
       except AttributeError:
           u = REQUEST['URL1']
           
       u = "%s/%s" % (u, urllib.quote(id))
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
Removed from v.1.20  
changed lines
  Added in v.1.58

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>