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

Diff for /zogiLib/zogiLib.py between versions 1.7 and 1.52

version 1.7, 2004/04/16 14:07:08 version 1.52, 2004/11/03 15:24:46
Line 6  from webdav.common import rfc1123_date Line 6  from webdav.common import rfc1123_date
   
 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
   import types
   import random
 from Globals import package_home  from Globals import package_home
   
 def getString(self,key,default=''):  ZOGIVERSION = "0.9.13b ROC:3.11.2004"
     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):  def cropf(f):
         """get path"""      """returns a float with reduced precision"""
         return getPath(self,'thumbtemplate.templ')      return float(int(f * 10000)/10000.0)
       
     ## def changeECHO_pageTemplateWeightForm(self):  
 ##         """change"""  def sendFile(self, filename, type):
 ##         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self)      """sends an object or a local file (from the product) as response"""
 ##         return pt()      paths = filename.split('/')
       object = self
 ##     def changeECHO_pageTemplateWeight(self,weight,content_type,RESPONSE=None):      # look for an object called filename
 ##         """change"""      for path in paths:
 ##         self.weight=weight          if hasattr(object, path):
 ##         self.content_type=content_type          object = getattr(object, path)
   
 ##         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)  
     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:          else:
             zpt = zogilib_NavTemplate(id, file, headers.get('content_type'))          object = None
           break
         self._setObject(id, zpt)      if object:
         ob = getattr(self, id)      # if the object exists then send it
       return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
       else:
         try:      # send a local file with the given content-type
             u = self.DestinationURL()      fn = os.path.join(package_home(globals()), filename)
         except AttributeError:      self.REQUEST.RESPONSE.setHeader("Content-Type", type)
             u = REQUEST['URL1']      self.REQUEST.RESPONSE.write(file(fn).read())
       return
         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:  def browserCheck(self):
             ob.pt_setTitle(title)      """check the browsers request to find out the browser type"""
         return ob      bt = {}
     else:      ua = self.REQUEST.get_header("HTTP_USER_AGENT")
         file = REQUEST.form.get('file')      bt['ua'] = ua
         headers = getattr(file, 'headers', None)      bt['isIE'] = False
         if headers is None or not file.filename:      bt['isN4'] = False
             zpt = zogiLib_mainTemplate(id)      if string.find(ua, 'MSIE') > -1:
           bt['isIE'] = True
         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(Image):
     """einzelnes Image"""      """einzelnes Image"""
     meta_type="zogiImage"      meta_type="zogiImage"
   
       manage_options=ZopePageTemplate.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
Line 197  class zogiImage(Image): Line 99  class zogiImage(Image):
   
     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 209  class zogiImage(Image): Line 111  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 ''                      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 ''  
   
   
 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 497  def manage_addZogiImage(self,id,title,ba Line 134  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
   
     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):      def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
         """images ablegen"""          """init"""
         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))          self.id=id
                 self.images.manage_addImage(image,fn)          self.title=title
             except:          self.dlServerURL = dlServerURL
                 print "ZOGILIB not imported:",image          self.basePath=basePath
           self.layout=layout
           self.dlTarget = dlTarget
                                   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
                           
                   
       def version(self):
           """version information"""
           return ZOGIVERSION
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):      def getContextStatic(self):
         """init"""          """get all the contexts which go to static pages"""
   
         self.id=id          try:
         self.title=title              dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
         self.digilibBaseUrl=digilibBaseUrl              contexts=dom.getElementsByTagName("context")
         self.localFileBase=localFileBase  
         #self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))  
         self._setObject('mainTemplate',zogiLib_mainTemplate(id='mainTemplate',version=version))  
         self.generateImageFolder()  
   
               ret=[]
               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 []
   
     manage_options = Folder.manage_options+(      def getContextDatabases(self):
             {'label':'Main Config','action':'changeZogiLibForm'},          """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 option_js(self):  
         """option_js"""  
         ret="""function setDLParam(e) {  
           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 {  
             document.setParameter(s.name, s.value);  
             document.display(9);  
           }  
         }"""  
         return ret          return ret
           except:
                                                   
                                       return []
     def navigation_js(self):  
         """Javascript"""  
         fileName=os.path.join(package_home(globals()),'js/navigation.js')  
         return file(fileName).read()  
   
   
       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="""          print label
         var baseUrl = '%s'; """% self.REQUEST['URL0']          if label:
         ret+="""              ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
         newParameter('fn', '', 1);          for set in sets:
         newParameter('pn', '1', 1);              ret+="<table>"
         newParameter('ws', '1.0', 1);              for node in set.childNodes:
         newParameter('mo', '', 1);                  if hasattr(node,'tagName'):
         newParameter('mk', '', 3);                      tag=node.tagName
         newParameter('wx', '0.0', 2);                      label=node.getAttribute("label")
         newParameter('wy', '0.0', 2);                      if not label:
         newParameter('ww', '1.0', 2);                          label=tag
         newParameter('wh', '1.0', 2);                      text=getText(node.childNodes)
         newParameter('pt', '0', 9);                      ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text)
         newParameter('brgt', '0.0', 1);              ret+="</table>"
         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';  
         """  
         return ret          return ret
   
                   
     def generateScalerImg(self,requestString):      def getMetaData(self):
         """generate Scaler IMG Tag"""          """getMetaData"""
         retStr=self.digilibBaseUrl+requestString          try:
         jS="""<script type="text/javascript">picsize = bestPicSize('scaler');              dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
         document.write('<img id="pic" src="%s&dw='+picsize.width+'&dh='+picsize.height+'" />')          except:
         </script>"""%retStr              return "error metadata"
         return jS  
   
     def changeZogiLibForm(self):          contexts=dom.getElementsByTagName("context")
         """Main configuration"""          ret=[]
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)          db=self.getDLParam("db")
         return pt()          ob=self.getDLParam("object")
           
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):          fn=self.getDLParam("fn")
         """change it"""          pn=self.getDLParam("pn")
         self.title=title          if not fn:
         self.digilibBaseUrl=digilibBaseUrl              fn=""
         self.localFileBase=localFileBase          if not pn:
               pn=""
           if not ob:
               ob=""
   
         if RESPONSE is not None:          for context in contexts:
             RESPONSE.redirect('manage_main')              metaDataLinks=context.getElementsByTagName("meta-datalink")
               for metaDataLink in metaDataLinks:
   
                   if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1):
                           
     def nav_html(self,fileName):                      link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
         """navigations frame"""                      label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
         ## currently not in use                      url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
         # suche nach index.meta mit zogilib thumb info  
           
         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()                      return self.formatHTML(link,label,url)
           
               metaDataLinks=context.getElementsByTagName("meta-baselink")
           
     def index_html(self):              for metaDataLink in metaDataLinks:
         """main action"""  
   
                   if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1):
   
         #pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_image.zpt').__of__(self)                      link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
         #return pt()                      label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
         return self.mainTemplate()                      url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
   
     def storeQuery(self):                      return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
         """storeQuery in session"""          return ret
         self.REQUEST.SESSION['query']={}  
         for fm in self.REQUEST.form.keys():  
             self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]  
   
         self.REQUEST.SESSION['dlInfo']=self.getDlInfo()  
                   
     def getParam(self,param):      def getDLInfo(self):
         """Gebe Parameter aus"""          """get DLInfo from digilib server"""
           paramH={}
           baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
         try:          try:
             return self.REQUEST.SESSION['query'][param]              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
         except:          except:
             return None              return {}
   
     def getPageNum(self):  
         """PAgenum"""  
         pn=self.getParam('pn')  
         if pn:  
             return pn  
         else:  
             return 1  
   
     def biggerWS(self):      def createHeadJS(self):
         """ws+1"""          """generate all javascript tags for head"""
         ws=self.getParam('ws')      self.checkQuery()
         if ws:      bt = self.REQUEST.SESSION.get('browserType', {})
             return int(ws)+1          if bt['staticHTML']:
         else:              return
             return 2  
   
     def options(self):          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
         """showoptions"""  
         pt=PageTemplateFile('Products/zogiLib/zpt/optionwindow.zpt').__of__(self)  
         return pt()          return pt()
   
               def createParamJS(self):
     def smallerWS(self):          """generate javascript for parameters only"""
         """ws-11"""      self.checkQuery()
         ws=self.getParam('ws')      bt = self.REQUEST.SESSION['browserType']
         if ws:          if bt['staticHTML']:
             if int(ws)==1:  
                 return                  return
             else:  
                 return int(ws)-1  
         else:  
             return 1  
                   
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
           return pt()
                   
     def setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):  
         """setze Parameter"""  
         ret=""  
   
         if brgt:      def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
             self.REQUEST.SESSION['query']['brgt']=brgt          """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 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']
   
         if cont:          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
             self.REQUEST.SESSION['query']['cont']=cont          return pt()
   
         if pn:      def createAuxDiv(self):
             self.REQUEST.SESSION['query']['pn']=pn          """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()
   
         if ws:  
             self.REQUEST.SESSION['query']['ws']=ws  
   
         if rot:      def option_js(self):
             self.REQUEST.SESSION['query']['rot']=rot          """javascript"""
           return sendFile(self, 'js/option.js', 'text/plain')
                           
         for param in self.REQUEST.SESSION['query'].keys():      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')
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      def optionwindow(self):
           """showoptions"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
           else:
               tp = "viewingTools.zpt"
               if hasattr(self, tp):
                   pt = getattr(self, tp)
           else:
                   pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          return pt()
   
       def mark1(self):
           """mark image"""
           return sendFile(self, 'images/mark1.gif', 'image/gif')
   
       def mark2(self):
           """mark image"""
           return sendFile(self, 'images/mark2.gif', 'image/gif')
   
       def mark3(self):
           """mark image"""
           return sendFile(self, 'images/mark3.gif', 'image/gif')
   
       def mark4(self):
           """mark image"""
           return sendFile(self, 'images/mark4.gif', 'image/gif')
   
       def mark5(self):
           """mark image"""
           return sendFile(self, 'images/mark5.gif', 'image/gif')
   
       def mark6(self):
           """mark image"""
           return sendFile(self, 'images/mark6.gif', 'image/gif')
   
       def mark7(self):
           """mark image"""
           return sendFile(self, 'images/mark7.gif', 'image/gif')
   
       def mark8(self):
           """mark image"""
           return sendFile(self, 'images/mark8.gif', 'image/gif')
   
       def corner1(self):
           """mark image"""
           return sendFile(self, 'images/olinks.gif', 'image/gif')
   
       def corner2(self):
           """mark image"""
           return sendFile(self, 'images/orechts.gif', 'image/gif')
   
       def corner3(self):
           """mark image"""
           return sendFile(self, 'images/ulinks.gif', 'image/gif')
   
       def corner4(self):
           """mark image"""
           return sendFile(self, 'images/urechts.gif', 'image/gif')
   
       def up_img(self):
           """mark image"""
           return sendFile(self, 'images/up.gif', 'image/gif')
   
       def down_img(self):
           """mark image"""
           return sendFile(self, 'images/down.gif', 'image/gif')
   
       def left_img(self):
           """mark image"""
           return sendFile(self, 'images/left.gif', 'image/gif')
   
       def right_img(self):
           """mark image"""
           return sendFile(self, 'images/right.gif', 'image/gif')
         
     def mirrorPage(self,mi):  
         """mirror"""  
         ret=""  
         try:  
             splitted=self.REQUEST.SESSION['query']['mo'].split(',')  
         except:  
             splitted=[]  
                   
         if mi=="h":  
                                           
             if 'hmir' in splitted:      def index_html(self):
                 splitted.remove('hmir')          """main action"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           tp = "zogiLibMainTemplate"
           
           if hasattr(self, tp):
           pt = getattr(self, tp)
             else:              else:
                 splitted.append('hmir')              tpt = self.layout
   
         if mi=="v":              if bt['staticHTML']:
                   tpt = "static"
   
             if 'vmir' in splitted:              pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)
                 splitted.remove('vmir')  
             else:  
                 splitted.append('vmir')  
   
           return pt()
   
         self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")  
                   
       def storeQuery(self, more = None):
           """storeQuery in session"""
           dlParams = {}
           for fm in self.REQUEST.form.keys():
               dlParams[fm] = self.REQUEST.form[fm]
           # look for more
           if more:
               for fm in more.split('&'):
                   try:
                       pv = fm.split('=')
                       dlParams[pv[0]] = pv[1]
                   except:
                       pass
                   
           # parse digilib mode parameter
           if 'mo' in dlParams:
               if len(dlParams['mo']) > 0:
                   modes=dlParams['mo'].split(',')
           else:
               modes=[]
               
           wid = self.getWID()
           self.REQUEST.set('wid', wid)
           self.setSubSession('dlQuery', dlParams)
           self.setSubSession('dlModes', modes)
           self.setSubSession('dlInfo', self.getDLInfo())
           if not self.REQUEST.SESSION.has_key('browserType'):
               self.REQUEST.SESSION['browserType'] = browserCheck(self)
                   
           return
                   
         for param in self.REQUEST.SESSION['query'].keys():      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
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      def zogilibPath(self, otherbase=None):
           """returns an URL to the zogiLib instance"""
           url = self.REQUEST['URL1']
           # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           if type(otherbase) is str:
               url += otherbase
           else:
               url += self.basePath
           # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
   
       def zogilibAction(self, action, otherbase=None, wid=None):
           """returns a URL with zogilib path, action and wid"""
           url = self.zogilibPath(otherbase)
           url += action
           if wid:
               url += '?wid=' + wid
           else:
               url += '?wid=' + self.getWID()
           return url
   
       def getSubSession(self, key, default=None):
           """returns an element from a session with a wid"""
           wid = self.getWID()
           return self.REQUEST.SESSION.get(key+'_'+wid, default)
   
       def setSubSession(self, key, value):
           """puts an element in a session with a wid"""
           wid = self.getWID()
           self.REQUEST.SESSION.set(key+'_'+wid, value)
           return
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      def getWID(self):
           """returns a (new) window id"""
           wid = self.REQUEST.get('wid')
           if not wid:
               wid = 'digi_'+str(int(random.random()*10000))
               print "new WID:", wid
           return wid
                   
     def decode(self,strR):      def getDLParam(self, param):
         """decode &"""          """returns parameter"""
           try:
               return self.getSubSession('dlQuery').get(param)
           except:
               return
                   
         return re.sub('\&amp','\&',strR)      def setDLParam(self, param, value):
           """sets parameter"""
           dlParams = self.getSubSession('dlQuery')
           #try:
           dlParams[param] = value
           #except:
           #    self.setSubSession('dlQuery', {param: value})
           return
           
     def wholePage(self):      def getAllDLParams(self):
         """zoom out"""          """parameter string for digilib"""
           dlParams = self.getSubSession('dlQuery')
           # save modes
           modes = self.getSubSession('dlModes')
           dlParams['mo'] = string.join(modes, ',')
           # assemble query string
         ret=""          ret=""
           for param in dlParams.keys():
               if dlParams[param] is None: continue
               val = str(dlParams[param])
               if val != "":
                   ret += param + "=" + val + "&"
                   
         self.REQUEST.SESSION['query']['ww']=1          # omit trailing "&"
         self.REQUEST.SESSION['query']['wh']=1          return ret.rstrip('&')
         self.REQUEST.SESSION['query']['wx']=0  
         self.REQUEST.SESSION['query']['wy']=0  
                           
         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)
                   
     def prevPage(self,pn=None):          if pn:
         """next page"""              # unmark
         ret=""              self.setDLParam('mk', None)
               self.setDLParam('pn', pn)
               
           return self.display()
   
   
       def display(self):
           """(re)display page"""
           if not self.getDLParam('wid'):
               wid = self.getWID()
               self.setDLParam('wid', wid)
               
           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 == 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
   
         if pn and pn>0:      def isStaticHTML(self):
             pn=str(int(pn)-1)          """returns if the page is using static HTML only"""
           self.checkQuery()
       return self.REQUEST.SESSION['browserType']['staticHTML']
                   
       def getPT(self):
           """pagenums"""
           di = self.getSubSession('dlInfo')
           if di:
               return int(di['pt'])
           else:
               return 1
   
         self.REQUEST.form['pn']=pn      def getPN(self):
           """Pagenum"""
           pn = self.getDLParam('pn')
           try:
               return int(pn)
           except:
               return 1
                   
         for param in self.REQUEST.form.keys():      def getBiggerWS(self):
           """ws+1"""
           ws = self.getDLParam('ws')
           try:
               return float(ws)+0.5
           except:
               return 1.5
                           
             ret+=param+"="+str(self.REQUEST.form[param])+"&"      def getSmallerWS(self):
           """ws-1"""
           ws=self.getDLParam('ws')
           try:
               return max(float(ws)-0.5, 1)
           except:
               return 1
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      def hasMode(self, mode):
           """returns if mode is in the diglib mo parameter"""
           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')
   
           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_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 firstPage(self):      def changeZogiLibForm(self):
         """erste Seite"""          """Main configuration"""
         return self.setParam(pn="1")          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
           return pt()
           
     def lastPage(self):      def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
         """letzte Seite"""          """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?"
                   
     def nextPage(self,pn=None):          if RESPONSE is not None:
         """next page"""              RESPONSE.redirect('manage_main')
         ret=""  
                   
         try:  
             pn=str(int(pn)+1)  
         except:  
             pn=str(2)  
   
         self.REQUEST.form['pn']=pn  
                   
         for param in self.REQUEST.form.keys():      ##
             ret+=param+"="+str(self.REQUEST.form[param])+"&"      ## 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?"
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          return msg+"\n\nfixed all zogilib instances in: "+obj.title
   
                   
 def manage_addZogiLibForm(self):  def manage_addZogiLibForm(self):
     """interface for adding zogilib"""      """interface for adding zogilib"""
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiLibForm').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
     return pt()      return pt()
   
 def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",RESPONSE=None):  def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
     """add dgilib"""      """add dgilib"""
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version)      newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
     self.Destination()._setObject(id,newObj)      self.Destination()._setObject(id,newObj)
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   class zogiLibPageTemplate(ZopePageTemplate):
       """pageTemplate Objekt"""
       meta_type="zogiLib_pageTemplate"
   
   
   ## def __init__(self, id, text=None, contentType=None):
   ##         self.id = str(id)
   ##         self.ZBindings_edit(self._default_bindings)
   ##         if text is None:
   ##             text = open(self._default_cont).read()
   ##         self.pt_edit(text, contentType)
   
   def manage_addZogiLibPageTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
       return pt()
   
   def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
   
       id = str(id)
       self._setObject(id, zogiLibPageTemplate(id))
       ob = getattr(self, id)
       if not layout: layout = "book"
       ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/zogiLibMain_%s.zpt'%layout)).read(),None)
       if title:
           ob.pt_setTitle(title)
       try:
           u = self.DestinationURL()
       except AttributeError:
           u = REQUEST['URL1']
           
       u = "%s/%s" % (u, urllib.quote(id))
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
Removed from v.1.7  
changed lines
  Added in v.1.52

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