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

Diff for /zogiLib/zogiLib.py between versions 1.46 and 1.62

version 1.46, 2004/10/05 17:43:53 version 1.62, 2006/02/01 12:25:11
Line 1 Line 1
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from AccessControl import ClassSecurityInfo
   from Globals import package_home
   from OFS.Folder import Folder
   from OFS.Image import Image
   from OFS.Image import File
   from OFS.SimpleItem import SimpleItem
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from OFS.Image import Image  from types import *
 from webdav.common import rfc1123_date  from Globals import package_home, ImageFile
   
 import xml.dom.minidom  
 from OFS.Folder import Folder  
 from xml_helpers import getUniqueElementText,getText  from xml_helpers import getUniqueElementText,getText
   import cgi
 import os  import os
   import random
 import re  import re
 import string  import string
 import urllib  import urllib
 import types  import xml.dom.minidom
 import random  
 from Globals import package_home  
   
 ZOGIVERSION = "0.9.10b ROC:5.10.2004"  ZOGIVERSION = "0.10.1b ROC 8.11.2005"
   
 def cropf(f):  def cropf(f):
     """returns a float with reduced precision"""      """returns a float with reduced precision"""
     return float(int(f * 10000)/10000.0)      return float(int(f * 10000)/10000.0)
   
   
 def sendFile(self, filename, type):  
     """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)  
     self.REQUEST.RESPONSE.setHeader("Content-Type", type)  
     self.REQUEST.RESPONSE.write(file(fn).read())  
     return  
   
 def browserCheck(self):  def browserCheck(self):
     """check the browsers request to find out the browser type"""      """check the browsers request to find out the browser type"""
     bt = {}      bt = {}
     ua = self.REQUEST.get_header("HTTP_USER_AGENT")      ua = self.REQUEST.get_header("HTTP_USER_AGENT")
     bt['ua'] = ua      bt['ua'] = ua
     bt['isIE'] = string.find(ua, 'MSIE') > -1      bt['isIE'] = False
     bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1) and not bt['isIE']      bt['isN4'] = False
       if string.find(ua, 'MSIE') > -1:
           bt['isIE'] = True
       else:
           bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
           
       try:
     nav = ua[string.find(ua, '('):]      nav = ua[string.find(ua, '('):]
     ie = string.split(nav, "; ")[1]      ie = string.split(nav, "; ")[1]
     if string.find(ie, "MSIE") > -1:      if string.find(ie, "MSIE") > -1:
         bt['versIE'] = string.split(ie, " ")[1]          bt['versIE'] = string.split(ie, " ")[1]
       except: pass
       
     bt['isMac'] = string.find(ua, 'Macintosh') > -1      bt['isMac'] = string.find(ua, 'Macintosh') > -1
     bt['isWin'] = string.find(ua, 'Windows') > -1      bt['isWin'] = string.find(ua, 'Windows') > -1
     bt['isIEWin'] = bt['isIE'] and bt['isWin']      bt['isIEWin'] = bt['isIE'] and bt['isWin']
Line 63  def browserCheck(self): Line 53  def browserCheck(self):
     return bt      return bt
   
           
 class zogiImage(Image):  class zogiImage(SimpleItem):
     """einzelnes Image"""      """einzelnes Image"""
     meta_type="zogiImage"      meta_type="zogiImage"
   
     manage_options=ZopePageTemplate.manage_options+(      manage_options=SimpleItem.manage_options+(
         {'label':'Main config','action':'changeZogiImageForm'},          {'label':'Main config','action':'changeZogiImageForm'},
        )         )
           
Line 85  class zogiImage(Image): Line 75  class zogiImage(Image):
         self.content_type=content_type          self.content_type=content_type
         self.precondition=precondition          self.precondition=precondition
   
     def getData(self):      #def getData(self):
         """getUrlData"""      #    """getUrlData"""
         return urllib.urlopen(self.baseUrl+self.queryString)      #    return urllib.urlopen(self.baseUrl+self.queryString)
   
     def changeZogiImageForm(self):      def changeZogiImageForm(self):
         """Main configuration"""          """Main configuration"""
Line 105  class zogiImage(Image): Line 95  class zogiImage(Image):
   
     def index_html(self, REQUEST, RESPONSE):      def index_html(self, REQUEST, RESPONSE):
         """service the request by redirecting to digilib server"""          """service the request by redirecting to digilib server"""
         print "REDIRECT: ", self.baseUrl+self.queryString  
         RESPONSE.redirect(self.baseUrl+self.queryString)          RESPONSE.redirect(self.baseUrl+self.queryString)
         return ''          return ''
                   
     def index_html2(self, REQUEST, RESPONSE):      def rescale(self,width=None,height=None):
         """          """andere parameter im querystring"""
         Modified version of OFS/Image.py          qs=cgi.parse_qs(self.queryString)
                   for x in qs.keys():
         The default view of the contents of a File or Image.              if type(qs[x]) is ListType:
                   qs[x]=qs[x][0]
         Returns the contents of the file or image.  Also, sets the          
         Content-Type HTTP header to the objects content type.          if width:
         """              qs['dw']=width
           if height:
         # HTTP If-Modified-Since header handling.              qs['dh']=height
         header=REQUEST.get_header('If-Modified-Since', None)  
         if header is not None:          
             header=header.split( ';')[0]          qsneu=urllib.urlencode(qs)
             # Some proxies seem to send invalid date strings for this          self.queryString=qsneu
             # header. If the date string is not valid, we ignore it          return "done"
             # rather than raise an error to be generally consistent  
             # with common servers such as Apache (which can usually  
             # understand the screwy date string as a lucky side effect  
             # of the way they parse it).  
             # This happens to be what RFC2616 tells us to do in the face of an  
             # invalid date.  
             try:    mod_since=long(DateTime(header).timeTime())  
             except: mod_since=None  
             if mod_since is not None:  
                 if self._p_mtime:  
                     last_mod = long(self._p_mtime)  
                 else:  
                     last_mod = long(0)  
                 if last_mod > 0 and last_mod <= mod_since:  
                     # Set header values since apache caching will return Content-Length  
                     # of 0 in response if size is not set here  
                     RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', self.size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     self.ZCacheable_set(None)  
                     RESPONSE.setStatus(304)  
                     return ''  
   
         if self.precondition and hasattr(self,self.precondition):  
             # Grab whatever precondition was defined and then  
             # execute it.  The precondition will raise an exception  
             # if something violates its terms.  
             c=getattr(self,self.precondition)  
             if hasattr(c,'isDocTemp') and c.isDocTemp:  
                 c(REQUEST['PARENTS'][1],REQUEST)  
             else:  
                 c()  
   
         # HTTP Range header handling  
         range = REQUEST.get_header('Range', None)  
         request_range = REQUEST.get_header('Request-Range', None)  
         if request_range is not None:  
             # Netscape 2 through 4 and MSIE 3 implement a draft version  
             # Later on, we need to serve a different mime-type as well.  
             range = request_range  
         if_range = REQUEST.get_header('If-Range', None)  
         if range is not None:  
             ranges = HTTPRangeSupport.parseRange(range)  
   
             if if_range is not None:  
                 # Only send ranges if the data isn't modified, otherwise send  
                 # the whole object. Support both ETags and Last-Modified dates!  
                 if len(if_range) > 1 and if_range[:2] == 'ts':  
                     # ETag:  
                     if if_range != self.http__etag():  
                         # Modified, so send a normal response. We delete  
                         # the ranges, which causes us to skip to the 200  
                         # response.  
                         ranges = None  
                 else:  
                     # Date  
                     date = if_range.split( ';')[0]  
                     try: mod_since=long(DateTime(date).timeTime())  
                     except: mod_since=None  
                     if mod_since is not None:  
                         if self._p_mtime:  
                             last_mod = long(self._p_mtime)  
                         else:  
                             last_mod = long(0)  
                         if last_mod > mod_since:  
                             # Modified, so send a normal response. We delete  
                             # the ranges, which causes us to skip to the 200  
                             # response.  
                             ranges = None  
   
             if ranges:  
                 # Search for satisfiable ranges.  
                 satisfiable = 0  
                 for start, end in ranges:  
                     if start < self.size:  
                         satisfiable = 1  
                         break  
   
                 if not satisfiable:  
                     RESPONSE.setHeader('Content-Range',  
                         'bytes */%d' % self.size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', self.size)  
                     RESPONSE.setStatus(416)  
                     return ''  
   
                 ranges = HTTPRangeSupport.expandRanges(ranges, self.size)  
                                   
                 if len(ranges) == 1:  
                     # Easy case, set extra header and return partial set.  
                     start, end = ranges[0]  
                     size = end - start  
   
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Content-Range',  
                         'bytes %d-%d/%d' % (start, end - 1, self.size))  
                     RESPONSE.setStatus(206) # Partial content  
   
                     data = urllib.urlopen(self.baseUrl+self.queryString).read()  
                     if type(data) is StringType:  
                         return data[start:end]  
   
                     # Linked Pdata objects. Urgh.  
                     pos = 0  
                     while data is not None:  
                         l = len(data.data)  
                         pos = pos + l  
                         if pos > start:  
                             # We are within the range  
                             lstart = l - (pos - start)  
   
                             if lstart < 0: lstart = 0  
   
                             # find the endpoint  
                             if end <= pos:  
                                 lend = l - (pos - end)  
   
                                 # Send and end transmission  
                                 RESPONSE.write(data[lstart:lend])  
                                 break  
   
                             # Not yet at the end, transmit what we have.  
                             RESPONSE.write(data[lstart:])  
   
                         data = data.next  
   
                     return ''  
   
                 else:  
                     boundary = choose_boundary()  
   
                     # Calculate the content length  
                     size = (8 + len(boundary) + # End marker length  
                         len(ranges) * (         # Constant lenght per set  
                             49 + len(boundary) + len(self.content_type) +  
                             len('%d' % self.size)))  
                     for start, end in ranges:  
                         # Variable length per set  
                         size = (size + len('%d%d' % (start, end - 1)) +  
                             end - start)  
   
   
                     # Some clients implement an earlier draft of the spec, they  
                     # will only accept x-byteranges.  
                     draftprefix = (request_range is not None) and 'x-' or ''  
   
                     RESPONSE.setHeader('Content-Length', size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type',  
                         'multipart/%sbyteranges; boundary=%s' % (  
                             draftprefix, boundary))  
                     RESPONSE.setStatus(206) # Partial content  
   
                     data = urllib.urlopen(self.baseUrl+self.queryString).read()  
                     # The Pdata map allows us to jump into the Pdata chain  
                     # arbitrarily during out-of-order range searching.  
                     pdata_map = {}  
                     pdata_map[0] = data  
   
                     for start, end in ranges:  
                         RESPONSE.write('\r\n--%s\r\n' % boundary)  
                         RESPONSE.write('Content-Type: %s\r\n' %  
                             self.content_type)  
                         RESPONSE.write(  
                             'Content-Range: bytes %d-%d/%d\r\n\r\n' % (  
                                 start, end - 1, self.size))  
   
                         if type(data) is StringType:  
                             RESPONSE.write(data[start:end])  
   
                         else:  
                             # Yippee. Linked Pdata objects. The following  
                             # calculations allow us to fast-forward through the  
                             # Pdata chain without a lot of dereferencing if we  
                             # did the work already.  
                             first_size = len(pdata_map[0].data)  
                             if start < first_size:  
                                 closest_pos = 0  
                             else:  
                                 closest_pos = (  
                                     ((start - first_size) >> 16 << 16) +  
                                     first_size)  
                             pos = min(closest_pos, max(pdata_map.keys()))  
                             data = pdata_map[pos]  
   
                             while data is not None:  
                                 l = len(data.data)  
                                 pos = pos + l  
                                 if pos > start:  
                                     # We are within the range  
                                     lstart = l - (pos - start)  
   
                                     if lstart < 0: lstart = 0  
   
                                     # find the endpoint  
                                     if end <= pos:  
                                         lend = l - (pos - end)  
   
                                         # Send and loop to next range  
                                         RESPONSE.write(data[lstart:lend])  
                                         break  
   
                                     # Not yet at the end, transmit what we have.  
                                     RESPONSE.write(data[lstart:])  
   
                                 data = data.next  
                                 # Store a reference to a Pdata chain link so we  
                                 # don't have to deref during this request again.  
                                 pdata_map[pos] = data  
   
                     # Do not keep the link references around.  
                     del pdata_map  
   
                     RESPONSE.write('\r\n--%s--\r\n' % boundary)  
                     return ''  
   
         RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))  
         RESPONSE.setHeader('Content-Type', self.content_type)  
         RESPONSE.setHeader('Content-Length', self.size)  
         RESPONSE.setHeader('Accept-Ranges', 'bytes')  
   
         # Don't cache the data itself, but provide an opportunity  
         # for a cache manager to set response headers.  
         self.ZCacheable_set(None)  
   
     #return "zogiimage: "+self.baseUrl+self.queryString  
         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"""
Line 390  def manage_addZogiImage(self,id,title,ba Line 131  def manage_addZogiImage(self,id,title,ba
   
   
 class zogiLib(Folder):  class zogiLib(Folder):
     """StandardElement"""      """digilib frontend with ZOPE"""
   
     meta_type="zogiLib"      meta_type="zogiLib"
     #xxxx      #xxxx
       security=ClassSecurityInfo()
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
             {'label':'Main Config','action':'changeZogiLibForm'},              {'label':'Main Config','action':'changeZogiLibForm'},
Line 414  class zogiLib(Folder): Line 156  class zogiLib(Folder):
         else:          else:
             self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"              self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
           self.manage_addFolder('template')
   
   
   # form templates
       main_book      = PageTemplateFile('zpt/main_book', globals())
       main_image     = PageTemplateFile('zpt/main_image', globals())
       main_metaData  = PageTemplateFile('zpt/main_metadata', globals())
       #main_static    = PageTemplateFile('zpt/main_static', globals())
       options        = PageTemplateFile('zpt/options', globals())
       changeForm     = PageTemplateFile('zpt/changeForm', globals())
   
   # display templates
       aux_divs       = PageTemplateFile('zpt/aux_divs', globals())
       #aux_divsN4     = PageTemplateFile('zpt/aux_divsN4', globals())
       img_div        = PageTemplateFile('zpt/img_div', globals())
       
   # javascripts
       head_js        = PageTemplateFile('zpt/head_js', globals())
       jslib_js       = PageTemplateFile('js/baselib.js', globals())
       dllib_js       = PageTemplateFile('js/dllib.js', globals())
       
   # graphic files
       arr_right = ImageFile('images/right.gif', globals())
       arr_left  = ImageFile('images/left.gif', globals())
       arr_up    = ImageFile('images/up.gif', globals())
       arr_down  = ImageFile('images/down.gif', globals())
       mark1     = ImageFile('images/mark1.gif', globals())
       mark2     = ImageFile('images/mark2.gif', globals())
       mark3     = ImageFile('images/mark3.gif', globals())
       mark4     = ImageFile('images/mark4.gif', globals())
       mark5     = ImageFile('images/mark5.gif', globals())
       mark6     = ImageFile('images/mark6.gif', globals())
       mark7     = ImageFile('images/mark7.gif', globals())
       mark8     = ImageFile('images/mark8.gif', globals())
       corner1   = ImageFile('images/olinks.gif', globals())
       corner2   = ImageFile('images/orechts.gif', globals())
       corner3   = ImageFile('images/ulinks.gif', globals())
       corner4   = ImageFile('images/urechts.gif', globals())    
   
   
       security.declareProtected('View','getLayout')
       def getLayout(self):
           """get Layout"""
           return self.layout
   
     def version(self):      def version(self):
         """version information"""          """version information"""
Line 468  class zogiLib(Folder): Line 254  class zogiLib(Folder):
   
         sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')          sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
         ret=""          ret=""
         print label          #print label
         if label:          if label:
             ret+="""<a href="%s">%s</a>"""%(viewUrl,label)              ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
         for set in sets:          for set in sets:
Line 535  class zogiLib(Folder): Line 321  class zogiLib(Folder):
     def getDLInfo(self):      def getDLInfo(self):
         """get DLInfo from digilib server"""          """get DLInfo from digilib server"""
         paramH={}          paramH={}
         baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"          baseUrl=self.getDLBaseUrl()+"/dlInfo-xml.jsp"
           #print "getdlinfo: ", baseUrl
         try:          try:
             url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING'])              url=urllib.urlopen(baseUrl+'?'+self.getAllDLParams())
             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:
Line 547  class zogiLib(Folder): Line 334  class zogiLib(Folder):
             return {}              return {}
   
   
     def createHeadJS(self):      def zogilibPath(self, otherbase=None):
         """generate all javascript tags for head"""          """returns an URL to the zogiLib instance"""
     self.checkQuery()          url = self.REQUEST['URL1']
     bt = self.REQUEST.SESSION.get('browserType', {})          # should end with "/"
         if bt['staticHTML']:          if len(url) > 0 and url[-1] != '/':
             return              url += '/'
           if type(otherbase) is str:
               url += otherbase
           else:
               url += self.basePath
           # should still end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)      def zogilibAction(self, action, otherbase=None):
         return pt()          """returns a URL with zogilib path and action"""
           url = self.zogilibPath(otherbase)
           url += action
           url += '?' + self.getAllDLParams();
           return url
   
     def createParamJS(self):      def getDLBaseUrl(self):
         """generate javascript for parameters only"""          """returns digilib base URL (sans servlet path)"""
     self.checkQuery()          if self.dlServerURL[-1] == '?':
     bt = self.REQUEST.SESSION['browserType']              # full Servlet URL -- remove last part
         if bt['staticHTML']:              si = self.dlServerURL.rindex('/servlet/')
             return              if si > 0:
                   return self.dlServerURL[:si]
               else:
                   # no servlet part :-(
                   return "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
           else:
               return self.dlServerURL 
           
   
       def getScalerUrl(self,requestString=""):
           """send scaler url"""
           if self.dlServerURL[-1] == '?':
               # full Servlet URL
               return self.dlServerURL + requestString
           else:
               return self.dlServerURL+'/servlet/Scaler?'+requestString
   
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)      def scaledImage(self,requestString=None):
         return pt()          """scaled Image"""
           
           if not requestString:
               requestString=self.REQUEST['QUERY_STRING']
               
           self.REQUEST.RESPONSE.redirect(self.getScalerUrl(requestString))
           
           return True
                   
                                                   
     def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):      def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
Line 578  class zogiLib(Folder): Line 399  class zogiLib(Folder):
         # if not explicitly defined take normal request          # if not explicitly defined take normal request
         if not requestString:          if not requestString:
             requestString = self.getAllDLParams()              requestString = self.getAllDLParams()
         url = self.dlServerURL+'/servlet/Scaler?'+requestString          url = self.getScalerUrl(requestString=requestString)
         # construct bottom and side insets          # construct bottom and side insets
         b_par = ""          b_par = ""
         s_par = ""          s_par = ""
Line 618  class zogiLib(Folder): Line 439  class zogiLib(Folder):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
         return pt()          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 option_js(self):  
         """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 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)  
                   
         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 index_html(self):      def index_html(self):
         """main action"""          """main action"""
     self.checkQuery()      self.checkQuery()
     bt = self.REQUEST.SESSION['browserType']          tp = "main_template"
         tp = "zogiLibMainTemplate"  
           
         if hasattr(self, tp):  
         pt = getattr(self, tp)  
         else:  
             tpt = self.layout              tpt = self.layout
                           
             if bt['staticHTML']:          if not hasattr(self, 'template'):
                 tpt = "static"              # create template folder if it doesn't exist
                               print "no template folder -- creating"
             pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)              self.manage_addFolder('template')
                           
           pt = getattr(self.template, 'main_'+tpt)
         return pt()          return pt()
   
       def checkQuery(self):
           """make shure that the query has been saved"""
           if not self.REQUEST.has_key('dlParams'):
               self.storeQuery()
           if not self.REQUEST.SESSION.has_key('browserType'):
               bt = browserCheck(self)
               self.REQUEST.SESSION.set('browserType', bt)            
   
     def storeQuery(self, more = None):      def storeQuery(self, more=None, withpt=False):
         """storeQuery in session"""          """parse query parameters into a hash in REQUEST"""
         dlParams = {}          params = {}
         for fm in self.REQUEST.form.keys():          for fm in self.REQUEST.form.keys():
             dlParams[fm] = self.REQUEST.form[fm]              params[fm] = self.REQUEST.form[fm]
         # look for more          # look for more
         if more:          if more:
             for fm in more.split('&'):              for fm in more.split('&'):
                 try:                  try:
                     pv = fm.split('=')                      pv = fm.split('=')
                     dlParams[pv[0]] = pv[1]                      params[pv[0]] = pv[1]
                 except:                  except:
                     pass                      pass
                                   
         # parse digilib mode parameter          # parse digilib mode parameter
         if 'mo' in dlParams:          if 'mo' in params:
             if len(dlParams['mo']) > 0:              if len(params['mo']) > 0:
                 modes=dlParams['mo'].split(',')                  modes=params['mo'].split(',')
         else:          else:
             modes=[]              modes = [];
                           
         wid = self.getWID()          self.REQUEST.set('dlParams', params)
         self.REQUEST.set('wid', wid)          self.REQUEST.set('dlModes', modes)
         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  
   
     def checkQuery(self):          # trigger get pt (from dlInfo) if requested
     """check if the query has been stored"""          if withpt:
     if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) :              pt = self.getPT()
         print "ZOGILIB: have to store query!!"  
         self.storeQuery()  
         return  
   
     def zogilibPath(self, otherbase=None):  
         """returns an URL to the zogiLib instance"""  
         url = self.REQUEST['URL1']  
         # should end with "/"  
         if len(url) > 0 and url[-1] != '/':  
             url += '/'  
         if type(otherbase) is str:  
             url += otherbase  
         else:  
             url += self.basePath  
         # should end with "/"  
         if len(url) > 0 and url[-1] != '/':  
             url += '/'  
         return url  
   
     def zogilibAction(self, action, otherbase=None, wid=None):  
         """returns a URL with zogilib path, action and wid"""  
         url = self.zogilibPath(otherbase)  
         url += action  
         if wid:  
             url += '?wid=' + wid  
         else:  
             url += '?wid=' + self.getWID()  
         return url  
   
     def getSubSession(self, key, default=None):          return params
         """returns an element from a session with a wid"""  
         wid = self.getWID()  
         return self.REQUEST.SESSION.get(key+'_'+wid, default)  
   
     def setSubSession(self, key, value):  
         """puts an element in a session with a wid"""  
         wid = self.getWID()  
         self.REQUEST.SESSION.set(key+'_'+wid, value)  
         return  
   
     def getWID(self):  
         """returns a (new) window id"""  
         wid = self.REQUEST.get('wid')  
         if not wid:  
             wid = 'digi_'+str(int(random.random()*10000))  
             print "new WID:", wid  
         return wid  
                   
     def getDLParam(self, param):      def getDLParam(self, param, default=None):
         """returns parameter"""          """returns parameter or default"""
           self.checkQuery()
           dlParams = self.REQUEST.get('dlParams')
         try:          try:
             return self.getSubSession('dlQuery').get(param)              return dlParams[param]
         except:          except:
             return              return default
   
     def setDLParam(self, param, value):      def setDLParam(self, param, value):
         """sets parameter"""          """sets parameter"""
         dlParams = self.getSubSession('dlQuery')          self.checkQuery()
         #try:          dlParams = self.REQUEST.get('dlParams')
         dlParams[param] = value          dlParams[param] = value
         #except:  
         #    self.setSubSession('dlQuery', {param: value})  
         return          return
   
     def getAllDLParams(self):      def getAllDLParams(self):
         """parameter string for digilib"""          """parameter string for digilib"""
         dlParams = self.getSubSession('dlQuery')          self.checkQuery()
           dlParams = self.REQUEST.get('dlParams')
         # save modes          # save modes
         modes = self.getSubSession('dlModes')          modes = self.REQUEST.get('dlModes')
           if modes:
         dlParams['mo'] = string.join(modes, ',')          dlParams['mo'] = string.join(modes, ',')
         # assemble query string          # assemble query string
         ret = ""          ret = ""
Line 859  class zogiLib(Folder): Line 527  class zogiLib(Folder):
         # omit trailing "&"          # omit trailing "&"
         return ret.rstrip('&')          return ret.rstrip('&')
   
           
     def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
         """setze Parameter"""          """setze Parameter"""
   
Line 878  class zogiLib(Folder): Line 545  class zogiLib(Folder):
   
     def display(self):      def display(self):
         """(re)display page"""          """(re)display page"""
         if not self.getDLParam('wid'):  
             wid = self.getWID()  
             self.setDLParam('wid', wid)  
               
         params = self.getAllDLParams()          params = self.getAllDLParams()
                           
         if self.basePath:          if self.basePath:
Line 902  class zogiLib(Folder): Line 565  class zogiLib(Folder):
         """returns dlTarget"""          """returns dlTarget"""
         self.checkQuery()          self.checkQuery()
         s = self.dlTarget          s = self.dlTarget
         if s == None:          if (s is None) or (s == ""):
             s = ""  #            s = ""
 #         s = 'dl'              s = 'dl'
 #         if self.getDLParam('fn'):              if self.getDLParam('fn'):
 #             s += "_" + self.getDLParam('fn')                  s += "_" + self.getDLParam('fn')
 #         if self.getDLParam('pn'):              if self.getDLParam('pn'):
 #             s += "_" + self.getDLParam('pn')                  s += "_" + self.getDLParam('pn')
         return s  
   
     def setStaticHTML(self, static=True):          return s
         """sets the preference to static HTML"""  
         self.checkQuery()  
     self.REQUEST.SESSION['browserType']['staticHTML'] = static  
         return  
   
     def isStaticHTML(self):  
         """returns if the page is using static HTML only"""  
         self.checkQuery()  
     return self.REQUEST.SESSION['browserType']['staticHTML']  
   
     def getPT(self):  
         """pagenums"""  
         di = self.getSubSession('dlInfo_')  
         if di:  
             return int(di['pt'])  
         else:  
             return 1  
           
     def getPN(self):      def getPN(self):
         """Pagenum"""          """pagenumber"""
         pn = self.getDLParam('pn')          pn = int(self.getDLParam('pn', 1))
         try:          return pn
             return int(pn)  
         except:  
             return 1  
   
     def getBiggerWS(self):      def getPT(self):
         """ws+1"""          """number of total pages"""
         ws = self.getDLParam('ws')          pt = self.getDLParam('pt', None)
         try:          if pt is None:
             return float(ws)+0.5              # get pt from dlInfo
         except:              if self.REQUEST.has_key('dlInfo'):
             return 1.5                  info = self.REQUEST.get('dlInfo')
                       else:
     def getSmallerWS(self):                  info = self.getDLInfo()
         """ws-1"""                  self.REQUEST.set('dlInfo', info)
         ws=self.getDLParam('ws')              pt = int(info.get('pt', 1))
         try:              self.setDLParam('pt', pt)
             return max(float(ws)-0.5, 1)          return int(pt)
         except:  
             return 1  
   
     def hasMode(self, mode):      def hasMode(self, mode):
         """returns if mode is in the diglib mo parameter"""          """returns if mode is in the diglib mo parameter"""
         wid = self.getWID()          return (mode in self.REQUEST.get('dlModes'))
         return (mode in self.REQUEST.SESSION['dlModes_'+wid])  
   
     def hasNextPage(self):      def hasNextPage(self):
         """returns if there is a next page"""          """returns if there is a next page"""
Line 1128  class zogiLib(Folder): Line 767  class zogiLib(Folder):
         self.setDLParam('mk', None)          self.setDLParam('mk', None)
         return self.display()          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):      def dl_db(self,db):
         """set db"""          """set db"""
         self.setDLParam('db',db)          self.setDLParam('db',db)
Line 1230  def manage_addZogiLibPageTemplateForm(se Line 859  def manage_addZogiLibPageTemplateForm(se
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
     return pt()      return pt()
   
 def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,  def manage_addZogiLibPageTemplate(self, id=None, title=None, layout=None, text=None,
                            REQUEST=None, submit=None):                             REQUEST=None, submit=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
   
     id = str(id)      if not layout: layout = "book"
       if not id: id = "main_%s"%layout;
     self._setObject(id, zogiLibPageTemplate(id))      self._setObject(id, zogiLibPageTemplate(id))
     ob = getattr(self, id)      ob = getattr(self, id)
     if not layout: layout = "book"      ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/main_%s.zpt'%layout)).read(),None)
     ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/zogiLibMain_%s.zpt'%layout)).read(),None)  
     if title:      if title:
         ob.pt_setTitle(title)          ob.pt_setTitle(title)
     try:      try:
Removed from v.1.46  
changed lines
  Added in v.1.62

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