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

Diff for /zogiLib/zogiLib.py between versions 1.4 and 1.64

version 1.4, 2004/03/30 13:56:24 version 1.64, 2006/07/13 18:24:19
Line 1 Line 1
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from AccessControl import ClassSecurityInfo
   from Globals import package_home
   from OFS.Folder import Folder
   from OFS.Image import Image
   from OFS.Image import File
   from OFS.SimpleItem import SimpleItem
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from OFS.Image import Image  from types import *
 from webdav.common import rfc1123_date  from Globals import package_home, ImageFile
   from xml_helpers import getUniqueElementText,getText
 import xml.dom.minidom  import cgi
 from OFS.Folder import Folder  
 from xml_helpers import getText  
 import os  import os
   import random
 import re  import re
 import string  import string
 import urllib  import urllib
 from Globals import package_home  import xml.dom.minidom
   
 def getString(self,key,default=''):  
     try:  
         return self.REQUEST[key]  
     except:  
         return default  
   
       
 class zogiLib_navTemplate(ZopePageTemplate):  
     """pageTemplate Objekt"""  
     meta_type="zogiLib_navTemplate"  
   
     _default_content_fn = os.path.join(package_home(globals()),  
                                        'zpt/zogiLib_NavTemplateDefault.zpt')  
   
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'Copy to Filesystem','action':'copyContent'},  
        )  
   
     def getPath(self):  
         """get path"""  
         return getPath(self,'thumbtemplate.templ')  
       
     ## def changeECHO_pageTemplateWeightForm(self):  
 ##         """change"""  
 ##         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self)  
 ##         return pt()  
   
 ##     def changeECHO_pageTemplateWeight(self,weight,content_type,RESPONSE=None):  
 ##         """change"""  
 ##         self.weight=weight  
 ##         self.content_type=content_type  
   
 ##         if RESPONSE is not None:  
 ##             RESPONSE.redirect('manage_main')  
           
   
     def copyContent(self):  
         """copycontent to path"""  
   
         return "copied to:"+copyContent(self,'thumbtemplate.templ')  
           
       
 def manage_addZogiLib_NavTemplateForm(self):  
     """Form for adding"""  
     pt=PageTemplateFile('Products/zogiLib/zpt/AddZogilib_NavTemplate.zpt').__of__(self)  
     return pt()  
   
   
   
   
 def manage_addZogiLib_NavTemplate(self, id,title=None, text=None,  
                            REQUEST=None, submit=None):  
     "Add a Page Template with optional file content."  
   
           
     id = str(id)  ZOGIVERSION = "0.10.3b ROC 13.7.2006"
     if REQUEST is None:  
         self._setObject(id, zogilib_NavTemplate(id, text))  
         ob = getattr(self, id)  
                 
         if title:  def cropf(f):
             ob.pt_setTitle(title)      """returns a float with reduced precision"""
         return ob      return float(int(f * 10000)/10000.0)
     else:  
         file = REQUEST.form.get('file')  
         headers = getattr(file, 'headers', None)  def browserCheck(self):
         if headers is None or not file.filename:      """check the browsers request to find out the browser type"""
             zpt = zogilib_NavTemplate(id)      bt = {}
       ua = self.REQUEST.get_header("HTTP_USER_AGENT")
       bt['ua'] = ua
       bt['isIE'] = False
       bt['isN4'] = False
       if string.find(ua, 'MSIE') > -1:
           bt['isIE'] = True
         else:          else:
             zpt = zogilib_NavTemplate(id, file, headers.get('content_type'))          bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
   
         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
       
       bt['isMac'] = string.find(ua, 'Macintosh') > -1
       bt['isWin'] = string.find(ua, 'Windows') > -1
       bt['isIEWin'] = bt['isIE'] and bt['isWin']
       bt['isIEMac'] = bt['isIE'] and bt['isMac']
       bt['staticHTML'] = False
   
         if submit == " Add and Edit ":      return bt
             u = "%s/%s" % (u, quote(id))  
         REQUEST.RESPONSE.redirect(u+'/manage_main')  
     return ''  
   
   
           
 def readNavTemp(fileName):  
     """navtemp"""  
       
       
     if os.path.exists(fileName+"/index.meta"):  
         dom=xml.dom.minidom.parse(fileName+"/index.meta")  
     else:  
         return None  
           
           
     try:  class zogiImage(SimpleItem):
         navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)  
     except:  
         navTag=None  
     return navTag  
       
 class zogiImage(Image):  
     """einzelnes Image"""      """einzelnes Image"""
     meta_type="zogiImage"      meta_type="zogiImage"
   
       manage_options=SimpleItem.manage_options+(
           {'label':'Main config','action':'changeZogiImageForm'},
          )
           
           
     def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):      def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
         """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"""
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiImageForm.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiImageForm.zpt')).__of__(self)
         return pt()          return pt()
           
     def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):      def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):
Line 149  class zogiImage(Image): Line 93  class zogiImage(Image):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'Main config','action':'changeZogiImageForm'},  
        )  
   
       
   
           
     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)
           
         The default view of the contents of a File or Image.  
   
         Returns the contents of the file or image.  Also, sets the  
         Content-Type HTTP header to the objects content type.  
         """  
   
         # 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:  
                     RESPONSE.setHeader('Content-Range',  
                         'bytes */%d' % self.size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     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  
                                 RESPONSE.write(data[lstart:lend])  
                                 break  
   
                             # Not yet at the end, transmit what we have.  
                             RESPONSE.write(data[lstart:])  
   
                         data = data.next  
   
                     return ''  
   
                 else:  
                     boundary = choose_boundary()  
   
                     # Calculate the content length  
                     size = (8 + len(boundary) + # End marker length  
                         len(ranges) * (         # Constant lenght per set  
                             49 + len(boundary) + len(self.content_type) +  
                             len('%d' % self.size)))  
                     for start, end in ranges:  
                         # Variable length per set  
                         size = (size + len('%d%d' % (start, end - 1)) +  
                             end - start)  
   
   
                     # 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  
                                         RESPONSE.write(data[lstart:lend])  
                                         break  
   
                                     # Not yet at the end, transmit what we have.  
                                     RESPONSE.write(data[lstart:])  
   
                                 data = data.next  
                                 # 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)  
                     return ''  
   
         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')  
   
         # Don't cache the data itself, but provide an opportunity  
         # for a cache manager to set response headers.  
         self.ZCacheable_set(None)  
   
         data=urllib.urlopen(self.baseUrl+self.queryString).read()  
           
         if type(data) is type(''):   
             RESPONSE.setBase(None)  
             return data  
   
         while data is not None:  
             RESPONSE.write(data.data)  
             data=data.next  
   
         return ''          return ''
   
       def rescale(self,width=None,height=None):
           """andere parameter im querystring"""
           qs=cgi.parse_qs(self.queryString)
           for x in qs.keys():
               if type(qs[x]) is ListType:
                   qs[x]=qs[x][0]
           
           if width:
               qs['dw']=width
           if height:
               qs['dh']=height
   
           
           qsneu=urllib.urlencode(qs)
           self.queryString=qsneu
           return "done"
   
 def manage_addZogiImageForm(self):  def manage_addZogiImageForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiImage.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
     return pt()      return pt()
   
   
 def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):  def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
     """add dgilib"""      """add zogiimage"""
     newObj=zogiImage(id,title,baseUrl, queryString)      newObj=zogiImage(id,title,baseUrl, queryString)
     self.Destination()._setObject(id,newObj)      self.Destination()._setObject(id,newObj)
     if RESPONSE is not None:      if RESPONSE is not None:
Line 437  def manage_addZogiImage(self,id,title,ba Line 131  def manage_addZogiImage(self,id,title,ba
   
   
 class zogiLib(Folder):  class zogiLib(Folder):
     """StandardElement"""      """digilib frontend with ZOPE"""
   
     meta_type="zogiLib"      meta_type="zogiLib"
       #xxxx
       security=ClassSecurityInfo()
   
     def getDlInfo(self):      manage_options = Folder.manage_options+(
         """DLInfo"""              {'label':'Main Config','action':'changeZogiLibForm'},
         paramH={}              )
         baseUrl=re.sub("servlet/Scaler","/dlInfo-xml.jsp",self.digilibBaseUrl)  
           
         url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])  
         dom=xml.dom.minidom.parse(url)  
         params=dom.getElementsByTagName('parameter')  
         for param in params:  
             paramH[param.getAttribute('name')]=param.getAttribute('value')  
         return paramH  
   
     def getPageNumTotal(self):  
         """pagenums"""  
         return self.getDlInfo()['pt']  
       
       
     def generateImageFolder(self):  
         """images ablegen"""  
         self.manage_addFolder('images')  
         for image in os.listdir("../lib/python/Products/zogiLib/images"):  
             fn=file("../lib/python/Products/zogiLib/images/"+image)  
               
             self.images.manage_addImage(image,fn)  
           
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase):      def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
         """init"""          """init"""
   
         self.id=id          self.id=id
         self.title=title          self.title=title
         self.digilibBaseUrl=digilibBaseUrl          self.dlServerURL = dlServerURL
         self.localFileBase=localFileBase          self.basePath = basePath
         self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))          self.layout = layout
         self.generateImageFolder()          self.dlTarget = dlTarget
   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
               
           self.manage_addFolder('template')
   
   
   # form templates
       main_book      = PageTemplateFile('zpt/main_book', globals())
       main_image     = PageTemplateFile('zpt/main_image', globals())
       main_metaData  = PageTemplateFile('zpt/main_metadata', globals())
       #main_static    = PageTemplateFile('zpt/main_static', globals())
       options        = PageTemplateFile('zpt/options', globals())
       changeForm     = PageTemplateFile('zpt/changeForm', globals())
   
   # display templates
       aux_divs       = PageTemplateFile('zpt/aux_divs', globals())
       #aux_divsN4     = PageTemplateFile('zpt/aux_divsN4', globals())
       img_div        = PageTemplateFile('zpt/img_div', globals())
       
   # javascripts
       head_js        = PageTemplateFile('zpt/head_js', globals())
       jslib_js       = PageTemplateFile('js/baselib.js', globals())
       dllib_js       = PageTemplateFile('js/dllib.js', globals())
       
   # graphic files
       arr_right = ImageFile('images/right.gif', globals())
       arr_left  = ImageFile('images/left.gif', globals())
       arr_up    = ImageFile('images/up.gif', globals())
       arr_down  = ImageFile('images/down.gif', globals())
       mark1     = ImageFile('images/mark1.gif', globals())
       mark2     = ImageFile('images/mark2.gif', globals())
       mark3     = ImageFile('images/mark3.gif', globals())
       mark4     = ImageFile('images/mark4.gif', globals())
       mark5     = ImageFile('images/mark5.gif', globals())
       mark6     = ImageFile('images/mark6.gif', globals())
       mark7     = ImageFile('images/mark7.gif', globals())
       mark8     = ImageFile('images/mark8.gif', globals())
       corner1   = ImageFile('images/olinks.gif', globals())
       corner2   = ImageFile('images/orechts.gif', globals())
       corner3   = ImageFile('images/ulinks.gif', globals())
       corner4   = ImageFile('images/urechts.gif', globals())    
   
   
       security.declareProtected('View','getLayout')
       def getLayout(self):
           """get Layout"""
           return self.layout
       
       def version(self):
           """version information"""
           return ZOGIVERSION
   
       def getContextStatic(self):
           """get all the contexts which go to static pages"""
   
     manage_options = Folder.manage_options+(          try:
             {'label':'Main Config','action':'changeZogiLibForm'},              dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
             )              contexts=dom.getElementsByTagName("context")
   
     def option_js(self):              ret=[]
         """option_js"""              for context in contexts:
         ret="""function setParam(e) {                  name=getUniqueElementText(context.getElementsByTagName("name"))
         if (document.all) s=e.srcElement;  
                     else s=e.target;                  link=getUniqueElementText(context.getElementsByTagName("link"))
                         if (window.opener) location=window.opener.location                  if name or link:
                         else location=document.location                      ret.append((name,link))
                         location=" %s/setParam?"+s.name+'='+s.value;  
                         }"""%self.REQUEST['URL1']  
         return ret          return ret
           except:
               return []
                                                   
       def getContextDatabases(self):
           """get all dynamic contexts"""
           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))
                                                   
     def navigation_js(self):              return ret
         """Javascript"""          except:
                   
         return file("../lib/python/Products/zogiLib/js/navigation.js").read()              return []
   
   
       def formatHTML(self,url,label=None,viewUrl=None):
                           
     def generateTopJavaScript(self):          sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
         """generate script"""          ret=""
         ret="""var baseUrl = '%s'; """% self.REQUEST['URL0']          #print label
         ret+="""newParameter('fn', '%s', '', 1);          if label:
                 newParameter('pn', '%s', '1', 1);              ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
                 newParameter('ws', '%s', '1.0', 1);          for set in sets:
                 newParameter('mo', '%s', '', 1);              ret+="<table>"
                 newParameter('mk', '%s', '', 3);              for node in set.childNodes:
                 newParameter('wx', '%s', '0.0', 2);                  if hasattr(node,'tagName'):
                 newParameter('wy', '%s', '0.0', 2);                      tag=node.tagName
                 newParameter('ww', '%s', '1.0', 2);                      label=node.getAttribute("label")
                 newParameter('wh', '%s', '1.0', 2);                      if not label:
                 newParameter('pt', '%s', '%s', 9);                          label=tag
                 newParameter('brgt', '%s', '0.0', 1);                      text=getText(node.childNodes)
                 newParameter('cont', '%s', '0.0', 1);                      ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text)
                 newParameter('rot', '%s', '0.0', 1);              ret+="</table>"
                 newParameter('rgba', '%s', '', 1);          return ret
                 newParameter('rgbm', '%s', '', 1);  
                 newParameter('ddpix', '%s', '', 9);  
                 newParameter('ddpiy', '%s', '', 9);"""%(getString(self,'fn'),  
                  getString(self,'pn',1),  
                  getString(self,'ws',1.0),  
                  getString(self,'mo',''),  
                  getString(self,'mk',''),  
                  getString(self,'wx',0.0),  
                  getString(self,'wy',0.0),  
                  getString(self,'ww',1.0),  
                  getString(self,'wh',1.0),  
                  getString(self,'pt',100),getString(self,'pt',100),  
                  getString(self,'brgt',0.0),  
                  getString(self,'cont',0.0),  
                  getString(self,'rot',0.0),  
                  getString(self,'rgba','0/0/0'),  
                  getString(self,'rgbm','0/0/0'),  
                  getString(self,'ddpix',0.0),  
                  getString(self,'ddpiy',0.0)  
                  )  
   
         ret+="""  
   
         var wwidth, wheight;      def getMetaData(self):
         if (self.innerHeight) // all except Explorer          """getMetaData"""
         {          try:
         wwidth = self.innerWidth;              dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
         wheight = self.innerHeight;          except:
         }              return "error metadata"
         else if (document.documentElement && document.documentElement.clientHeight)  
         // Explorer 6 Strict Mode  
         {  
         wwidth = document.documentElement.clientWidth;  
         wheight = document.documentElement.clientHeight;  
         }  
         else if (document.body) // other Explorers  
         {  
         wwidth = document.body.clientWidth;  
         wheight = document.body.clientHeight;  
         }  
   
         document.id="digilib"          contexts=dom.getElementsByTagName("context")
           ret=[]
           db=self.getDLParam("db")
           ob=self.getDLParam("object")
                   
         """          fn=self.getDLParam("fn")
         return ret          pn=self.getDLParam("pn")
           if not fn:
               fn=""
           if not pn:
               pn=""
           if not ob:
               ob=""
   
           for context in contexts:
               metaDataLinks=context.getElementsByTagName("meta-datalink")
               for metaDataLink in metaDataLinks:
   
                   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"))
                                   
                       return self.formatHTML(link,label,url)
                                   
               metaDataLinks=context.getElementsByTagName("meta-baselink")
                   
               for metaDataLink in metaDataLinks:
                   
     def generateScalerImg(self,requestString):                  if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1):
         """generate Scaler Tag"""  
         retStr=self.digilibBaseUrl+requestString  
         jS="""<script type="text/javascript">  
         document.write("<img id=\\\"pic\\\" src=\\\"%s&dw="+wwidth+"&dh="+wheight+"\\\"/>")</script>"""%retStr  
         return jS  
   
     def changeZogiLibForm(self):                      link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
         """Main configuration"""                      label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)                      url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
         return pt()  
       
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):  
         """change it"""  
         self.title=title  
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
                       return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
           return ret
                           
     def nav_html(self,fileName):  
         """navigations frame"""  
   
         # suche nach index.meta mit zogilib thumb info      def getDLInfo(self):
           """get DLInfo from digilib server"""
           paramH={}
           baseUrl=self.getDLBaseUrl()+"/dlInfo-xml.jsp"
           #print "getdlinfo: ", baseUrl
           try:
               url=urllib.urlopen(baseUrl+'?'+self.getAllDLParams())
               dom=xml.dom.minidom.parse(url)
               params=dom.getElementsByTagName('parameter')
               for param in params:
                   paramH[param.getAttribute('name')]=param.getAttribute('value')
               return paramH
           except:
               return {}
                   
         templ=readNavTemp(self.localFileBase+"/"+fileName)  
         if not templ:  
             templ=readNavTemp(self.localFileBase+"/"+fileName.split("/")[0])  
             if not templ:  
                 return self.topTemplate.document_src()  
   
         return urllib.urlopen(templ).read()      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 still end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
   
       def zogilibAction(self, action, otherbase=None):
           """returns a URL with zogilib path and action"""
           url = self.zogilibPath(otherbase)
           url += action
           url += '?' + self.getAllDLParams();
           return url
       
       def getDLBaseUrl(self):
           """returns digilib base URL (sans servlet path)"""
           if self.dlServerURL[-1] == '?':
               # full Servlet URL -- remove last part
               si = self.dlServerURL.rindex('/servlet/')
               if si > 0:
                   return self.dlServerURL[:si]
               else:
                   # no servlet part :-(
                   return "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
           else:
               return self.dlServerURL 
           
   
       def getScalerUrl(self,requestString=""):
           """send scaler url"""
           if self.dlServerURL[-1] == '?':
               # full Servlet URL
               return self.dlServerURL + requestString
           else:
               return self.dlServerURL+'/servlet/Scaler?'+requestString
       
       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"""
           self.checkQuery()
           bt = self.getBrowserType()
           # 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:
               requestString = self.getAllDLParams()
           url = self.getScalerUrl(requestString=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 = ""
           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">'
               else:
                   tag += '<div id="scaler">'
               tag += '<script type="text/javascript">'
               tag += "var ps = bestPicSize(getElement('scaler'));"
               # 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>'
               if bt['isN4']:
                   tag += '</ilayer>'
               else:
                   tag += '</div>'
           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 index_html(self):      def index_html(self):
         """main action"""          """main action"""
           self.checkQuery()
           tp = "main_template"
           tpt = self.layout
           
           if not hasattr(self, 'template'):
               # create template folder if it doesn't exist
               print "no template folder -- creating"
               self.manage_addFolder('template')
   
           pt = getattr(self.template, 'main_'+tpt)
         pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_book.zpt').__of__(self)  
         return pt()          return pt()
   
     def storeQuery(self):      def checkQuery(self):
         """storeQuery in session"""          """make shure that the query has been saved"""
         self.REQUEST.SESSION['query']={}          if not self.REQUEST.has_key('dlParams'):
               self.storeQuery()
   
       def storeQuery(self, more=None, withpt=False):
           """parse query parameters into a hash in REQUEST"""
           params = {}
         for fm in self.REQUEST.form.keys():          for fm in self.REQUEST.form.keys():
             self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]              params[fm] = self.REQUEST.form[fm]
           # look for more
         self.REQUEST.SESSION['dlInfo']=self.getDlInfo()          if more:
                       for fm in more.split('&'):
     def getParam(self,param):  
         """Gebe Parameter aus"""  
         try:          try:
             return self.REQUEST.SESSION['query'][param]                      pv = fm.split('=')
                       params[pv[0]] = pv[1]
         except:          except:
             return None                      pass
   
     def getPageNum(self):          # parse digilib mode parameter
         """PAgenum"""          if 'mo' in params:
         pn=self.getParam('pn')              if len(params['mo']) > 0:
         if pn:                  modes=params['mo'].split(',')
             return pn  
         else:  
             return 1  
   
     def biggerWS(self):  
         """ws+1"""  
         ws=self.getParam('ws')  
         if ws:  
             return int(ws)+1  
         else:  
             return 2  
   
     def options(self):  
         """showoptions"""  
         pt=PageTemplateFile('Products/zogiLib/zpt/optionwindow.zpt').__of__(self)  
         return pt()  
   
           
     def smallerWS(self):  
         """ws-11"""  
         ws=self.getParam('ws')  
         if ws:  
             if int(ws)==1:  
                 return  
             else:              else:
                 return int(ws)-1              modes = [];
         else:  
             return 1  
           
                   
     def setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):          self.REQUEST.set('dlParams', params)
         """setze Parameter"""          self.REQUEST.set('dlModes', modes)
         ret=""  
   
         if brgt:          # trigger get pt (from dlInfo) if requested
             self.REQUEST.SESSION['query']['brgt']=brgt          if withpt:
               pt = self.getPT()
         if cont:  
             self.REQUEST.SESSION['query']['cont']=cont  
   
         if pn:  
             self.REQUEST.SESSION['query']['pn']=pn  
   
         if ws:          return params
             self.REQUEST.SESSION['query']['ws']=ws  
   
         if rot:  
             self.REQUEST.SESSION['query']['rot']=rot  
                           
         for param in self.REQUEST.SESSION['query'].keys():      def getDLParam(self, param, default=None):
                       """returns parameter or default"""
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"          self.checkQuery()
                   dlParams = self.REQUEST.get('dlParams')
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
   
      
     def mirrorPage(self,mi):  
         """mirror"""  
         ret=""  
         try:          try:
             splitted=self.REQUEST.SESSION['query']['mo'].split(',')              return dlParams[param]
         except:          except:
             splitted=[]              return default
           
         if mi=="h":  
                       
             if 'hmir' in splitted:  
                 splitted.remove('hmir')  
             else:  
                 splitted.append('hmir')  
   
         if mi=="v":  
   
             if 'vmir' in splitted:  
                 splitted.remove('vmir')  
             else:  
                 splitted.append('vmir')  
   
   
         self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")  
                   
       def setDLParam(self, param, value):
           """sets parameter"""
           self.checkQuery()
           dlParams = self.REQUEST.get('dlParams')
           dlParams[param] = value
           return
                   
       def getAllDLParams(self):
           """parameter string for digilib"""
           self.checkQuery()
           dlParams = self.REQUEST.get('dlParams')
           # save modes
           modes = self.REQUEST.get('dlModes')
           if modes:
               dlParams['mo'] = string.join(modes, ',')
           # assemble query string
           ret = ""
           for param in dlParams.keys():
               if dlParams[param] is None: continue
               val = str(dlParams[param])
               if val != "":
                   ret += param + "=" + val + "&"
                   
           # omit trailing "&"
           return ret.rstrip('&')
                   
         for param in self.REQUEST.SESSION['query'].keys():      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
           """setze Parameter"""
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"          self.setDLParam('brgt', brgt)
           self.setDLParam('cont', cont)
           self.setDLParam('ws', ws)
           self.setDLParam('rot', rot)
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          if pn:
               # unmark
               self.setDLParam('mk', None)
               self.setDLParam('pn', pn)
               
           return self.display()
   
       def getBrowserType(self):
           """get browser type object"""
           if self.REQUEST.SESSION.has_key('browserType'):
               return self.REQUEST.SESSION['browserType']
           else:
               bt = browserCheck(self)
               self.REQUEST.SESSION.set('browserType', bt)                        
               return bt
   
   
       def display(self):
           """(re)display page"""
           params = self.getAllDLParams()
               
           if self.basePath:
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
           else:
               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 is None) or (s == ""):
   #            s = ""
               s = 'dl'
               if self.getDLParam('fn'):
                   s += "_" + self.getDLParam('fn')
               if self.getDLParam('pn'):
                   s += "_" + self.getDLParam('pn')
   
           return s
   
       def getPN(self):
           """pagenumber"""
           pn = int(self.getDLParam('pn', 1))
           return pn
                   
     def decode(self,strR):      def getPT(self):
         """decode &"""          """number of total pages"""
           pt = self.getDLParam('pt', None)
           if pt is None:
               # get pt from dlInfo
               if self.REQUEST.has_key('dlInfo'):
                   info = self.REQUEST.get('dlInfo')
               else:
                   info = self.getDLInfo()
                   self.REQUEST.set('dlInfo', info)
               pt = int(info.get('pt', 1))
               self.setDLParam('pt', pt)
           return int(pt)
       
       def hasMode(self, mode):
           """returns if mode is in the diglib mo parameter"""
           return (mode in self.REQUEST.get('dlModes'))
   
       def hasNextPage(self):
           """returns if there is a next page"""
           pn = self.getPN()
           pt = self.getPT()
           return (pn < pt)
      
       def hasPrevPage(self):
           """returns if there is a previous page"""
           pn = self.getPN()
           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.getBrowserType()['staticHTML'] = True
           return self.display()
   
       def dl_DynamicHTML(self):
           """set rendering to dynamic HTML"""
           self.checkQuery()
           self.getBrowserType()['staticHTML'] = False
           return self.display()
           
       def dl_HMirror(self):
           """mirror action"""
           modes = self.getSubSession('dlModes')
           if 'hmir' in modes:
               modes.remove('hmir')
           else:
               modes.append('hmir')
   
           return self.display()
          
       def dl_VMirror(self):
           """mirror action"""
           modes = self.getSubSession('dlModes')
           if 'vmir' in modes:
               modes.remove('vmir')
           else:
               modes.append('vmir')
   
           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):
           """zoom out action"""
           self.setDLParam('ww', 1)
           self.setDLParam('wh', 1)
           self.setDLParam('wx', 0)
           self.setDLParam('wy', 0)
           return self.display()
           
       def dl_PrevPage(self):
           """next page action"""
           pn = self.getPN() - 1
           if pn < 1:
               pn = 1
           self.setDLParam('pn', pn)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
           
       def dl_NextPage(self):
           """next page action"""
           pn = self.getPN() + 1
           pt = self.getPT()
           if pn > pt:
               pn = pt
           self.setDLParam('pn', pn)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
   
       def dl_FirstPage(self):
           """first page action"""
           self.setDLParam('pn', 1)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
       
       def dl_LastPage(self):
           """last page action"""
           self.setDLParam('pn', self.getPT())
           # unmark
           self.setDLParam('mk', None)
           return self.display()
   
       def dl_db(self,db):
           """set db"""
           self.setDLParam('db',db)
           self.display()
                   
         return re.sub('\&amp','\&',strR)      def changeZogiLibForm(self):
           """Main configuration"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
           return pt()
           
     def wholePage(self):      def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
         """zoom out"""          """change it"""
         ret=""          self.title=title
           self.dlServerURL=dlServerURL
           self.basePath = basePath
           self.layout=version
           self.dlTarget = dlTarget
                   
         self.REQUEST.SESSION['query']['ww']=1          if dlToolbarBaseURL:
         self.REQUEST.SESSION['query']['wh']=1              self.dlToolbarBaseURL = dlToolbarBaseURL
         self.REQUEST.SESSION['query']['wx']=0          else:
         self.REQUEST.SESSION['query']['wy']=0              self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
                           
         for param in self.REQUEST.SESSION['query'].keys():          if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
                   
     def prevPage(self,pn=None):      ##
         """next page"""      ## odds and ends
         ret=""      ##
   
       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?"
   
         if pn and pn>0:          return msg+"\n\nfixed all zogilib instances in: "+obj.title
             pn=str(int(pn)-1)  
                   
   
         self.REQUEST.form['pn']=pn  def manage_addZogiLibForm(self):
       """interface for adding zogilib"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
       return pt()
                   
         for param in self.REQUEST.form.keys():  def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
       """add dgilib"""
       newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
       self.Destination()._setObject(id,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
                           
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  class zogiLibPageTemplate(ZopePageTemplate):
       """pageTemplate Objekt"""
       meta_type="zogiLib_pageTemplate"
   
     def firstPage(self):  
         """erste Seite"""  
         return self.setParam(pn="1")  
           
     def lastPage(self):  ## def __init__(self, id, text=None, contentType=None):
         """letzte Seite"""  ##         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 nextPage(self,pn=None):  def manage_addZogiLibPageTemplate(self, title=None, layout=None, text=None,
         """next page"""                             REQUEST=None, submit=None):
         ret=""      "Add a Page Template with optional file content."
                   
       if not layout: layout = "book"
       id = 'main_%s'%layout
       self._setObject(id, zogiLibPageTemplate(id))
       ob = getattr(self, id)
       ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/main_%s.zpt'%layout)).read(),None)
       if title:
           ob.pt_setTitle(title)
         try:          try:
             pn=str(int(pn)+1)          url = self.DestinationURL()
         except:      except AttributeError:
             pn=str(2)          url = REQUEST['URL1']
   
         self.REQUEST.form['pn']=pn  
           
         for param in self.REQUEST.form.keys():  
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
           
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
   
                   
 def manage_addZogiLibForm(self):      url = "%s/%s" % (url, urllib.quote(id))
     """interface for adding zogilib"""      REQUEST.RESPONSE.redirect(url+'/manage_main')
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiLibForm').__of__(self)      return ''
     return pt()  
   
 def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,RESPONSE=None):  
     """add dgilib"""  
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase)  
     self.Destination()._setObject(id,newObj)  
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
Removed from v.1.4  
changed lines
  Added in v.1.64

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