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

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

version 1.16, 2004/05/06 14:20:58 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):
     """schickt ein lokales file (aus dem Produkt) als response"""      """sends an object or a local file (from the product) as response"""
       paths = filename.split('/')
       object = self
       # look for an object called filename
       for path in paths:
           if hasattr(object, path):
               object = getattr(object, path)
           else:
               object = None
               break
       if object:
           # if the object exists then send it
           return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
       else:
           # send a local file with the given content-type
     fn = os.path.join(package_home(globals()), filename)      fn = os.path.join(package_home(globals()), filename)
     self.REQUEST.RESPONSE.setHeader('Content-Type', type)          self.REQUEST.RESPONSE.setHeader("Content-Type", type)
     self.REQUEST.RESPONSE.write(file(fn).read())      self.REQUEST.RESPONSE.write(file(fn).read())
     return      return
   
 class zogiLib_navTemplate(ZopePageTemplate):  def browserCheck(self):
     """pageTemplate Objekt"""      """check the browsers request to find out the browser type"""
     meta_type="zogiLib_navTemplate"      bt = {}
       ua = self.REQUEST.get_header("HTTP_USER_AGENT")
     _default_content_fn = os.path.join(package_home(globals()),      bt['ua'] = ua
                                        'zpt/zogiLib_NavTemplateDefault.zpt')      bt['isIE'] = False
       bt['isN4'] = False
     manage_options=ZopePageTemplate.manage_options+(      if string.find(ua, 'MSIE') > -1:
         {'label':'Copy to Filesystem','action':'copyContent'},          bt['isIE'] = True
        )  
   
     def getPath(self):  
         """get path"""  
         return getPath(self,'thumbtemplate.templ')  
       
   
     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)  
     if REQUEST is None:  
         self._setObject(id, zogilib_NavTemplate(id, text))  
         ob = getattr(self, id)  
          
         if title:  
             ob.pt_setTitle(title)  
         return ob  
     else:  
         file = REQUEST.form.get('file')  
         headers = getattr(file, 'headers', None)  
         if headers is None or not file.filename:  
             zpt = zogilib_NavTemplate(id)  
         else:  
             zpt = zogilib_NavTemplate(id, file, headers.get('content_type'))  
   
         self._setObject(id, zpt)  
         ob = getattr(self, id)  
   
   
         try:  
             u = self.DestinationURL()  
         except AttributeError:  
             u = REQUEST['URL1']  
   
         if submit == " Add and Edit ":  
             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:  
         navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)  
     except:  
         navTag=None  
     return navTag  
   
 class zogiLib_mainTemplate(ZopePageTemplate):  
     """pageTemplate Objekt"""  
     meta_type="zogiLib_mainTemplate"  
   
       
     def __init__(self, id, text=None, content_type=None, version="book"):  
   
         default_content_string="zpt/zogiLibMain_%s.zpt"%version  
         self._default_content_fn = os.path.join(package_home(globals()),default_content_string)  
         self.id = str(id)  
         self.ZBindings_edit(self._default_bindings)  
         if text is None:  
             text = open(self._default_content_fn).read()  
         self.pt_edit(text, content_type)  
   
       
 def manage_addZogiLibMainTemplateForm(self):  
     """Form for adding"""  
     pt=PageTemplateFile('Products/ECHO_content/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."  
   
       
     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:  
         file = REQUEST.form.get('file')  
         headers = getattr(file, 'headers', None)  
         if headers is None or not file.filename:  
             zpt = zogiLib_mainTemplate(id)  
         else:          else:
             zpt = zogiLib_mainTemplate(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 ''  
   
           
 class zogiImage(Image):  class zogiImage(SimpleItem):
     """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 204  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):
           """service the request by redirecting to digilib server"""
           RESPONSE.redirect(self.baseUrl+self.queryString)
           return ''
   
     manage_options=ZopePageTemplate.manage_options+(      def rescale(self,width=None,height=None):
         {'label':'Main config','action':'changeZogiImageForm'},          """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):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
       return pt()
           
   
   def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
       """add zogiimage"""
       newObj=zogiImage(id,title,baseUrl, queryString)
       self.Destination()._setObject(id,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
                   
     def index_html(self, REQUEST, RESPONSE):  
         """  
         Modified version of OFS/Image.py  
                   
         The default view of the contents of a File or Image.  
   
         Returns the contents of the file or image.  Also, sets the  class zogiLib(Folder):
         Content-Type HTTP header to the objects content type.      """digilib frontend with ZOPE"""
         """  
   
         # 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):      meta_type="zogiLib"
             # Grab whatever precondition was defined and then      #xxxx
             # execute it.  The precondition will raise an exception      security=ClassSecurityInfo()
             # 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:      manage_options = Folder.manage_options+(
                     RESPONSE.setHeader('Content-Range',              {'label':'Main Config','action':'changeZogiLibForm'},
                         '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)      def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
           """init"""
                                                                   
                 if len(ranges) == 1:          self.id=id
                     # Easy case, set extra header and return partial set.          self.title=title
                     start, end = ranges[0]          self.dlServerURL = dlServerURL
                     size = end - start          self.basePath=basePath
           self.layout=layout
                     RESPONSE.setHeader('Last-Modified',          self.dlTarget = dlTarget
                         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          if dlToolbarBaseURL:
                                 RESPONSE.write(data[lstart:lend])              self.dlToolbarBaseURL = dlToolbarBaseURL
                                 break          else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
                             # Not yet at the end, transmit what we have.      security.declareProtected('View','getLayout')
                             RESPONSE.write(data[lstart:])      def getLayout(self):
           """get Layout"""
           return self.layout
       
       def version(self):
           """version information"""
           return ZOGIVERSION
   
                         data = data.next      def getContextStatic(self):
           """get all the contexts which go to static pages"""
   
                     return ''          try:
               dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
               contexts=dom.getElementsByTagName("context")
   
                 else:              ret=[]
                     boundary = choose_boundary()              for context in contexts:
                   name=getUniqueElementText(context.getElementsByTagName("name"))
   
                   link=getUniqueElementText(context.getElementsByTagName("link"))
                   if name or link:
                       ret.append((name,link))
               return ret
           except:
               return []
   
                     # Calculate the content length      def getContextDatabases(self):
                     size = (8 + len(boundary) + # End marker length          """get all dynamic contexts"""
                         len(ranges) * (         # Constant lenght per set          try:
                             49 + len(boundary) + len(self.content_type) +              dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
                             len('%d' % self.size)))              contexts=dom.getElementsByTagName("context")
                     for start, end in ranges:              ret=[]
                         # Variable length per set              for context in contexts:
                         size = (size + len('%d%d' % (start, end - 1)) +                  metaDataLinks=context.getElementsByTagName("meta-datalink")
                             end - start)                  for metaDataLink in metaDataLinks:
                       db=metaDataLink.getAttribute("db")
                       link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
                     # Some clients implement an earlier draft of the spec, they                      if db:
                     # will only accept x-byteranges.                          ret.append((db,link))
                     draftprefix = (request_range is not None) and 'x-' or ''                  metaDataLinks=context.getElementsByTagName("meta-baselink")
   
                     RESPONSE.setHeader('Content-Length', size)                  for metaDataLink in metaDataLinks:
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')                      db=metaDataLink.getAttribute("db")
                     RESPONSE.setHeader('Last-Modified',                      link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
                         rfc1123_date(self._p_mtime))                      if db:
                     RESPONSE.setHeader('Content-Type',                          ret.append((db,link))
                         '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              return ret
                                         RESPONSE.write(data[lstart:lend])          except:
                                         break  
   
                                     # Not yet at the end, transmit what we have.              return []
                                     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.      def formatHTML(self,url,label=None,viewUrl=None):
                     del pdata_map  
   
                     RESPONSE.write('\r\n--%s--\r\n' % boundary)          sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
                     return ''          ret=""
           print label
           if label:
               ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
           for set in sets:
               ret+="<table>"
               for node in set.childNodes:
                   if hasattr(node,'tagName'):
                       tag=node.tagName
                       label=node.getAttribute("label")
                       if not label:
                           label=tag
                       text=getText(node.childNodes)
                       ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text)
               ret+="</table>"
           return ret
   
         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 ''      def getMetaData(self):
           """getMetaData"""
           try:
               dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
           except:
               return "error metadata"
   
           contexts=dom.getElementsByTagName("context")
           ret=[]
           db=self.getDLParam("db")
           ob=self.getDLParam("object")
   
 def manage_addZogiImageForm(self):          fn=self.getDLParam("fn")
     """Form for adding"""          pn=self.getDLParam("pn")
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiImage.zpt').__of__(self)          if not fn:
     return pt()              fn=""
           if not pn:
               pn=""
           if not ob:
               ob=""
   
           for context in contexts:
               metaDataLinks=context.getElementsByTagName("meta-datalink")
               for metaDataLink in metaDataLinks:
   
 def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):                  if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1):
     """add dgilib"""  
     newObj=zogiImage(id,title,baseUrl, queryString)  
     self.Destination()._setObject(id,newObj)  
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
                       link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
                       label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
                       url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
   
                       return self.formatHTML(link,label,url)
   
 class zogiLib(Folder):              metaDataLinks=context.getElementsByTagName("meta-baselink")
     """StandardElement"""  
   
     meta_type="zogiLib"              for metaDataLink in metaDataLinks:
   
     def getDlInfo(self):                  if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1):
         """DLInfo"""                      
         paramH={}                      link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
         baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)                      label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
                       url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
                   
         url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])                      return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
           return ret
   
   
       def getDLInfo(self):
           """get DLInfo from digilib server"""
           paramH={}
           baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
           try:
               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:
               return {}
   
     def getPageNumTotal(self):  
         """pagenums"""  
         return self.getDlInfo()['pt'].encode('utf-8')  
           
       def createHeadJS(self):
           """generate all javascript tags for head"""
           self.checkQuery()
           bt = self.REQUEST.SESSION.get('browserType', {})
           if bt['staticHTML']:
               return
           
     def generateImageFolder(self):          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
         """images ablegen"""          return pt()
         self.manage_addFolder('images')  
         pathName=os.path.join(package_home(globals()),'images')  
         for image in os.listdir(pathName):  
             try:  
                                   
                 fn=file(os.path.join(pathName,image))      def createParamJS(self):
                 self.images.manage_addImage(image,fn)          """generate javascript for parameters only"""
             except:          self.checkQuery()
                 print "ZOGILIB not imported:",image          bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
                                   
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
           return pt()
                           
                   
       def getScalerUrl(self,requestString=None):
           """send scaler url"""
           if requestString:
               return self.dlServerURL+'/servlet/Scaler?'+requestString
           else:
               return self.dlServerURL+'/servlet/Scaler?'
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):      def scaledImage(self,requestString=None):
         """init"""          """scaled Image"""
   
         self.id=id          if not requestString:
         self.title=title              requestString=self.REQUEST['QUERY_STRING']
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase  
         #self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))  
         self._setObject('mainTemplate',zogiLib_mainTemplate(id='mainTemplate',version=version))  
         #self.generateImageFolder()  
   
           self.REQUEST.RESPONSE.redirect(self.getScalerUrl(requestString))
   
     manage_options = Folder.manage_options+(          return True
             {'label':'Main Config','action':'changeZogiLibForm'},  
             )  
   
     def option_js(self):  
         """option_js"""  
         ret="""  
           function setDLParam(e) {  
           var s;  
           if (document.all) {  
             s=e.srcElement;  
           } else {  
             s=e.target;  
           }  
           if (window.opener) {  
             window.opener.setParameter(s.name, s.value);  
             window.opener.display(9);  
           } else {  
             setParameter(s.name, s.value);  
             display(9);  
           }  
         }"""  
         return ret  
                                                   
       def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
           """generate Scaler IMG Tag"""
           self.checkQuery()
           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:
               requestString = self.getAllDLParams()
           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 = ""
           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 navigation_js(self):      def createScalerDiv(self, requestString = None, bottom = 0, side = 0, width=500, height=500):
         """Javascript"""          """generate scaler img and table with navigation arrows"""
         fileName = os.path.join(package_home(globals()),'js/js_lib.js')          self.checkQuery()
         js = file(fileName).read()          if requestString != None or bottom != 0 or side != 0:
         fileName = os.path.join(package_home(globals()),'js/dl_lib.js')              self.REQUEST.SESSION['scalerDiv'] = (requestString, bottom, side, width, height)
         js += file(fileName).read()          else:
         return js               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):
           """generate other divs"""
           self.checkQuery()
           bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
           if bt['isN4']:
               f = 'zpt/zogilib_divsN4.zpt'
           else:
               f = 'zpt/zogiLib_divs.zpt'
           pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self)
           return pt()
                           
     def generateTopJavaScript(self):  
         """generate script"""  
         ret="""  
         var baseUrl = '%s'; """% self.REQUEST['URL0']  
         ret+="""  
         newParameter('fn', '', 1);  
         newParameter('pn', '1', 1);  
         newParameter('ws', '1.0', 1);  
         newParameter('mo', '', 1);  
         newParameter('mk', '', 3);  
         newParameter('wx', '0.0', 2);  
         newParameter('wy', '0.0', 2);  
         newParameter('ww', '1.0', 2);  
         newParameter('wh', '1.0', 2);  
         newParameter('pt', '0', 9);  
         newParameter('brgt', '0.0', 1);  
         newParameter('cont', '0.0', 1);  
         newParameter('rot', '0.0', 1);  
         newParameter('rgba', '', 1);  
         newParameter('rgbm', '', 1);  
         newParameter('ddpix', '', 9);  
         newParameter('ddpiy', '', 9);  
         var picsize = new Size(100, 100);  
         document.id='digilib';  
   
         """      def option_js(self):
         return ret          """javascript"""
           return sendFile(self, 'js/option.js', 'text/plain')
   
       def dl_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/dllib.js', 'text/plain')
   
       def js_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/baselib.js', 'text/plain')
                   
     def generateScalerImg(self,requestString):      def optionwindow(self):
         """generate Scaler IMG Tag"""          """showoptions"""
         retStr=self.digilibBaseUrl+requestString          self.checkQuery()
         jS="""<script type="text/javascript">var ps = bestPicSize('scaler');          bt = self.REQUEST.SESSION['browserType']
         document.write('<img id="pic" src="%s&dw='+ps.width+'&dh='+ps.height+'" />')          if bt['staticHTML']:
         </script>"""%retStr              pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
         return jS          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)
   
           return pt()
   
     def mark1(self):      def mark1(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark1.gif', 'image/gif')          return sendFile(self, 'images/mark1.gif', 'image/gif')
         return  
   
     def mark2(self):      def mark2(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark2.gif', 'image/gif')          return sendFile(self, 'images/mark2.gif', 'image/gif')
         return  
   
     def mark3(self):      def mark3(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark3.gif', 'image/gif')          return sendFile(self, 'images/mark3.gif', 'image/gif')
         return  
   
     def mark4(self):      def mark4(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark4.gif', 'image/gif')          return sendFile(self, 'images/mark4.gif', 'image/gif')
         return  
   
     def mark5(self):      def mark5(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark5.gif', 'image/gif')          return sendFile(self, 'images/mark5.gif', 'image/gif')
         return  
   
     def mark6(self):      def mark6(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark6.gif', 'image/gif')          return sendFile(self, 'images/mark6.gif', 'image/gif')
         return  
   
     def mark7(self):      def mark7(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark7.gif', 'image/gif')          return sendFile(self, 'images/mark7.gif', 'image/gif')
         return  
   
     def mark8(self):      def mark8(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark8.gif', 'image/gif')          return sendFile(self, 'images/mark8.gif', 'image/gif')
         return  
   
     def corner1(self):      def corner1(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/olinks.gif', 'image/gif')          return sendFile(self, 'images/olinks.gif', 'image/gif')
         return  
   
     def corner2(self):      def corner2(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/orechts.gif', 'image/gif')          return sendFile(self, 'images/orechts.gif', 'image/gif')
         return file(fileName).read()  
   
     def corner3(self):      def corner3(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/ulinks.gif', 'image/gif')          return sendFile(self, 'images/ulinks.gif', 'image/gif')
         return file(fileName).read()  
   
     def corner4(self):      def corner4(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/urechts.gif', 'image/gif')          return sendFile(self, 'images/urechts.gif', 'image/gif')
         return file(fileName).read()  
   
       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 changeZogiLibForm(self):      def left_img(self):
         """Main configuration"""          """mark image"""
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)          return sendFile(self, 'images/left.gif', 'image/gif')
         return pt()  
           
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):      def right_img(self):
         """change it"""          """mark image"""
         self.title=title          return sendFile(self, 'images/right.gif', 'image/gif')
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
                           
     def nav_html(self,fileName):      def index_html(self):
         """navigations frame"""          """main action"""
         ## currently not in use          self.checkQuery()
         # suche nach index.meta mit zogilib thumb info          bt = self.REQUEST.SESSION['browserType']
                   tp = "zogiLibMainTemplate"
         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()          if hasattr(self, tp):
               pt = getattr(self, tp)
           else:
               tpt = self.layout
           
               if bt['staticHTML']:
                   tpt = "static"
           
     def index_html(self):              pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)
         """main action"""  
   
         #pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_image.zpt').__of__(self)          return pt()
         #return pt()  
         return self.mainTemplate()  
   
     def storeQuery(self):  
       def storeQuery(self, more = None):
         """storeQuery in session"""          """storeQuery in session"""
         self.REQUEST.SESSION['query']={}          dlParams = {}
         for fm in self.REQUEST.form.keys():          for fm in self.REQUEST.form.keys():
             self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]              dlParams[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('=')
                       dlParams[pv[0]] = pv[1]
         except:          except:
             return None                      pass
   
     def getPageNum(self):          # parse digilib mode parameter
         """PAgenum"""          if 'mo' in dlParams:
         pn=self.getParam('pn')              if len(dlParams['mo']) > 0:
         if pn:                  modes=dlParams['mo'].split(',')
             return pn  
         else:          else:
             return 1              modes=[]
   
     def biggerWS(self):          wid = self.getWID()
         """ws+1"""          self.REQUEST.set('wid', wid)
         ws=self.getParam('ws')          self.setSubSession('dlQuery', dlParams)
         if ws:          self.setSubSession('dlModes', modes)
             return int(ws)+1          self.setSubSession('dlInfo', self.getDLInfo())
         else:          if not self.REQUEST.SESSION.has_key('browserType'):
             return 2              self.REQUEST.SESSION['browserType'] = browserCheck(self)
   
     def options(self):          return
         """showoptions"""  
         pt=PageTemplateFile('Products/zogiLib/zpt/optionwindow.zpt').__of__(self)  
         return pt()  
   
       def checkQuery(self):
           """check if the query has been stored"""
           if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) :
               print "ZOGILIB: have to store query!!"
               self.storeQuery()
           return
                   
     def smallerWS(self):      def zogilibPath(self, otherbase=None):
         """ws-11"""          """returns an URL to the zogiLib instance"""
         ws=self.getParam('ws')          url = self.REQUEST['URL1']
         if ws:          # should end with "/"
             if int(ws)==1:          if len(url) > 0 and url[-1] != '/':
                 return 1              url += '/'
           if type(otherbase) is str:
               url += otherbase
             else:              else:
                 return int(ws)-1              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:          else:
             return 1              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 setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):      def getWID(self):
         """setze Parameter"""          """returns a (new) window id"""
         ret=""          wid = self.REQUEST.get('wid')
           if not wid:
         if brgt:              wid = 'digi_'+str(int(random.random()*10000))
             self.REQUEST.SESSION['query']['brgt']=brgt              print "new WID:", wid
           return wid
   
         if cont:      def getDLParam(self, param, default=None):
             self.REQUEST.SESSION['query']['cont']=cont          """returns parameter or default"""
           try:
               return self.getSubSession('dlQuery').get(param, default)
           except:
               return default
   
         if pn:      def setDLParam(self, param, value):
             self.REQUEST.SESSION['query']['pn']=pn          """sets parameter"""
           dlParams = self.getSubSession('dlQuery')
           #try:
           dlParams[param] = value
           #except:
           #    self.setSubSession('dlQuery', {param: value})
           return
   
         if ws:      def getAllDLParams(self):
             self.REQUEST.SESSION['query']['ws']=ws          """parameter string for digilib"""
           dlParams = self.getSubSession('dlQuery')
           # save modes
           modes = self.getSubSession('dlModes')
           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 + "&"
   
         if rot:          # omit trailing "&"
             self.REQUEST.SESSION['query']['rot']=rot          return ret.rstrip('&')
                           
         for param in self.REQUEST.SESSION['query'].keys():  
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
           """setze Parameter"""
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          self.setDLParam('brgt', brgt)
           self.setDLParam('cont', cont)
           self.setDLParam('ws', ws)
           self.setDLParam('rot', rot)
   
           if pn:
               # unmark
               self.setDLParam('mk', None)
               self.setDLParam('pn', pn)
         
     def mirrorPage(self,mi):          return self.display()
         """mirror"""  
         ret=""  
         try:  
             splitted=self.REQUEST.SESSION['query']['mo'].split(',')  
         except:  
             splitted=[]  
                   
         if mi=="h":  
                                           
             if 'hmir' in splitted:      def display(self):
                 splitted.remove('hmir')          """(re)display page"""
             else:          if not self.getDLParam('wid'):
                 splitted.append('hmir')              wid = self.getWID()
               self.setDLParam('wid', wid)
   
         if mi=="v":          params = self.getAllDLParams()
   
             if 'vmir' in splitted:          if self.basePath:
                 splitted.remove('vmir')              self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
             else:              else:
                 splitted.append('vmir')              self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
   
   
         self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")  
           
           
                   
       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
                   
         for param in self.REQUEST.SESSION['query'].keys():      def isStaticHTML(self):
           """returns if the page is using static HTML only"""
           self.checkQuery()
           return self.REQUEST.SESSION['browserType']['staticHTML']
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      def getPT(self):
           """pagenums"""
           di = self.getSubSession('dlInfo')
           if di:
               return int(di['pt'])
           else:
               return 1
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      def getPN(self):
           """Pagenum"""
           pn = self.getDLParam('pn')
           try:
               return int(pn)
           except:
               return 1
                   
     def decode(self,strR):      def getBiggerWS(self):
         """decode &"""          """ws+1"""
           ws = self.getDLParam('ws')
           try:
               return float(ws)+0.5
           except:
               return 1.5
                   
         return re.sub('\&amp','\&',strR)      def getSmallerWS(self):
           """ws-1"""
           ws=self.getDLParam('ws')
           try:
               return max(float(ws)-0.5, 1)
           except:
               return 1
           
     def wholePage(self):      def hasMode(self, mode):
         """zoom out"""          """returns if mode is in the diglib mo parameter"""
         ret=""          wid = self.getWID()
           return (mode in self.REQUEST.SESSION['dlModes_'+wid])
   
       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.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):
           """mirror action"""
           modes = self.getSubSession('dlModes')
           if 'hmir' in modes:
               modes.remove('hmir')
           else:
               modes.append('hmir')
                   
         self.REQUEST.SESSION['query']['ww']=1          return self.display()
         self.REQUEST.SESSION['query']['wh']=1  
         self.REQUEST.SESSION['query']['wx']=0  
         self.REQUEST.SESSION['query']['wy']=0  
                           
         for param in self.REQUEST.SESSION['query'].keys():      def dl_VMirror(self):
           """mirror action"""
           modes = self.getSubSession('dlModes')
           if 'vmir' in modes:
               modes.remove('vmir')
           else:
               modes.append('vmir')
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"          return self.display()
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      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_Unmark(self):
           """action to remove last mark"""
           mk = self.getDLParam('mk')
           if mk:
               marks = mk.split(',')
               marks.pop()
               mk = string.join(marks, ',')
               self.setDLParam('mk', mk)
           return self.display()
   
       def dl_db(self,db):
           """set db"""
           self.setDLParam('db',db)
           self.display()
                   
     def prevPage(self,pn=None):      def changeZogiLibForm(self):
         """next page"""          """Main configuration"""
         ret=""          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
           return pt()
   
         if pn and pn>0:      def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
             pn=str(int(pn)-1)          """change it"""
           self.title=title
           self.dlServerURL=dlServerURL
           self.basePath = basePath
           self.layout=version
           self.dlTarget = dlTarget
                   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
         self.REQUEST.form['pn']=pn          if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                   
         for param in self.REQUEST.form.keys():  
                           
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      ##
       ## 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?"
   
     def firstPage(self):          return msg+"\n\nfixed all zogilib instances in: "+obj.title
         """erste Seite"""  
         return self.setParam(pn="1")  
           
     def lastPage(self):  
         """letzte Seite"""  
   
   def manage_addZogiLibForm(self):
       """interface for adding zogilib"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
       return pt()
                   
     def nextPage(self,pn=None):  def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
         """next page"""      """add dgilib"""
         ret=""      newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
       self.Destination()._setObject(id,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
                   
         try:  
             pn=str(int(pn)+1)  
         except:  
             pn=str(2)  
   
         self.REQUEST.form['pn']=pn  class zogiLibPageTemplate(ZopePageTemplate):
       """pageTemplate Objekt"""
       meta_type="zogiLib_pageTemplate"
                   
         for param in self.REQUEST.form.keys():  
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  ## 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 generateDivs(self):  def manage_addZogiLibPageTemplateForm(self):
         """generate divs"""      """Form for adding"""
         pt=PageTemplateFile('Products/zogiLib/zpt/zogilib_divs').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
         return pt()          return pt()
   
         #divFileName=os.path.join(package_home(globals()),'zpt/zogilib_divs.zpt')  def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,
         #return open(divFileName).read()                             REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
                       
 def manage_addZogiLibForm(self):      id = str(id)
     """interface for adding zogilib"""      self._setObject(id, zogiLibPageTemplate(id))
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiLibForm').__of__(self)      ob = getattr(self, id)
     return pt()      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 ''
   
 def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",RESPONSE=None):  
     """add dgilib"""  
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version)  
     self.Destination()._setObject(id,newObj)  
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
Removed from v.1.16  
changed lines
  Added in v.1.58

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