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

Diff for /zogiLib/zogiLib.py between versions 1.3 and 1.18

version 1.3, 2004/03/26 14:19:50 version 1.18, 2004/06/02 17:32:54
Line 1 Line 1
   
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   from OFS.Image import Image
   from webdav.common import rfc1123_date
   
 import xml.dom.minidom  import xml.dom.minidom
 from OFS.Folder import Folder  from OFS.Folder import Folder
Line 18  def getString(self,key,default=''): Line 20  def getString(self,key,default=''):
     except:      except:
         return default          return default
   
   def sendFile(self, filename, type):
       """sends an object or a local file (in 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
           
 class zogiLib_navTemplate(ZopePageTemplate):  class BrowserCheck:
     """pageTemplate Objekt"""      """check the browsers request to find out the browser type"""
     meta_type="zogiLib_navTemplate"  
   
     _default_content_fn = os.path.join(package_home(globals()),  
                                        'zpt/zogiLib_NavTemplateDefault.zpt')  
   
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'Copy to Filesystem','action':'copyContent'},  
        )  
   
     def getPath(self):  
         """get path"""  
         return getPath(self,'thumbtemplate.templ')  
       
     ## def changeECHO_pageTemplateWeightForm(self):  
 ##         """change"""  
 ##         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self)  
 ##         return pt()  
   
 ##     def changeECHO_pageTemplateWeight(self,weight,content_type,RESPONSE=None):  
 ##         """change"""  
 ##         self.weight=weight  
 ##         self.content_type=content_type  
   
 ##         if RESPONSE is not None:  
 ##             RESPONSE.redirect('manage_main')  
           
   
     def copyContent(self):  
         """copycontent to path"""  
   
         return "copied to:"+copyContent(self,'thumbtemplate.templ')      def __init__(self, zope):
       self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
       self.isIE = string.find(self.ua, 'MSIE') > -1
       self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and not self.isIE
       self.nav = self.ua[string.find(self.ua, '('):]
       ie = string.split(self.nav, "; ")[1]
       if string.find(ie, "MSIE") > -1:
           self.versIE = string.split(ie, " ")[1]
       self.isMac = string.find(self.ua, 'Macintosh') > -1
       self.isWin = string.find(self.ua, 'Windows') > -1
       self.isIEWin = self.isIE and self.isWin
       self.isIEMac = self.isIE and self.isMac
                   
           
 def manage_addZogiLib_NavTemplateForm(self):  def manage_addZogiLibMainTemplateForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/zogiLib/zpt/AddZogilib_NavTemplate.zpt').__of__(self)      #FIXME:???
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/AddOSAS_thumbTemplate.zpt')).__of__(self)
     return pt()      return pt()
   
   
   
   
 def manage_addZogiLib_NavTemplate(self, id,title=None, text=None,  def manage_addZogiLibMainTemplate(self, id,title=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."
       #FIXME:???
       
     id = str(id)      id = str(id)
     if REQUEST is None:      if REQUEST is None:
         self._setObject(id, zogilib_NavTemplate(id, text))          self._setObject(id, zogiLib_mainTemplate(id, text))
         ob = getattr(self, id)          ob = getattr(self, id)
                 
         if title:          if title:
Line 79  def manage_addZogiLib_NavTemplate(self, Line 83  def manage_addZogiLib_NavTemplate(self,
         file = REQUEST.form.get('file')          file = REQUEST.form.get('file')
         headers = getattr(file, 'headers', None)          headers = getattr(file, 'headers', None)
         if headers is None or not file.filename:          if headers is None or not file.filename:
             zpt = zogilib_NavTemplate(id)              zpt = zogiLib_mainTemplate(id)
         else:          else:
             zpt = zogilib_NavTemplate(id, file, headers.get('content_type'))              zpt = zogiLib_mainTemplate(id, file, headers.get('content_type'))
   
         self._setObject(id, zpt)          self._setObject(id, zpt)
         ob = getattr(self, id)          ob = getattr(self, id)
Line 98  def manage_addZogiLib_NavTemplate(self, Line 102  def manage_addZogiLib_NavTemplate(self,
     return ''      return ''
   
   
   class zogiImage(Image):
       """einzelnes Image"""
       meta_type="zogiImage"
                   
 def readNavTemp(fileName):      manage_options=ZopePageTemplate.manage_options+(
     """navtemp"""          {'label':'Main config','action':'changeZogiImageForm'},
          )
           
           
     if os.path.exists(fileName+"/index.meta"):      def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
         dom=xml.dom.minidom.parse(fileName+"/index.meta")          """init"""
     else:          self.id=id
         return None          self.title=title
           self.baseUrl=baseUrl
           self.queryString=queryString
           self.content_type=content_type
           self.precondition=precondition
   
       def getData(self):
           """getUrlData"""
           return urllib.urlopen(self.baseUrl+self.queryString)
           
       def changeZogiImageForm(self):
           """Main configuration"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiImageForm.zpt')).__of__(self)
           return pt()
           
     try:      def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):
         navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)          """change it"""
     except:          self.title=title
         navTag=None          self.baseUrl=baseUrl
     return navTag          self.queryString=queryString
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                   
 class zogiLib(Folder):  
     """StandardElement"""  
   
     meta_type="zogiLib"      def index_html(self, REQUEST, RESPONSE):
           """
           Modified version of OFS/Image.py
   
     def getDlInfo(self):          The default view of the contents of a File or Image.
         """DLInfo"""  
         paramH={}  
         baseUrl=re.sub("servlet/Scaler","/dlInfo-xml.jsp",self.digilibBaseUrl)  
                   
         url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])          Returns the contents of the file or image.  Also, sets the
         dom=xml.dom.minidom.parse(url)          Content-Type HTTP header to the objects content type.
         params=dom.getElementsByTagName('parameter')          """
         for param in params:  
             paramH[param.getAttribute('name')]=param.getAttribute('value')  
         return paramH  
   
     def getPageNumTotal(self):          # HTTP If-Modified-Since header handling.
         """pagenums"""          header=REQUEST.get_header('If-Modified-Since', None)
         return self.getDlInfo()['pt']          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()
           
     def generateImageFolder(self):          # HTTP Range header handling
         """images ablegen"""          range = REQUEST.get_header('Range', None)
         self.manage_addFolder('images')          request_range = REQUEST.get_header('Request-Range', None)
         for image in os.listdir("../lib/python/Products/zogiLib/images"):          if request_range is not None:
             fn=file("../lib/python/Products/zogiLib/images/"+image)              # 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 ''
                           
             self.images.manage_addImage(image,fn)                  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
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase):                              # Not yet at the end, transmit what we have.
         """init"""                              RESPONSE.write(data[lstart:])
   
         self.id=id                          data = data.next
         self.title=title  
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase  
         self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))  
         self.generateImageFolder()  
   
                       return ''
   
     manage_options = Folder.manage_options+(                  else:
             {'label':'Main Config','action':'changeZogiLibForm'},                      boundary = choose_boundary()
             )  
   
     def option_js(self):                      # Calculate the content length
         """option_js"""                      size = (8 + len(boundary) + # End marker length
         ret="""function setParam(e) {                          len(ranges) * (         # Constant lenght per set
         if (document.all) s=e.srcElement;                              49 + len(boundary) + len(self.content_type) +
                     else s=e.target;                              len('%d' % self.size)))
                         if (window.opener) location=window.opener.location                      for start, end in ranges:
                         else location=document.location                          # Variable length per set
                         location=" %s/setParam?"+s.name+'='+s.value;                          size = (size + len('%d%d' % (start, end - 1)) +
                         }"""%self.REQUEST['URL1']                              end - start)
         return ret  
                           
                                               # Some clients implement an earlier draft of the spec, they
     def navigation_js(self):                      # will only accept x-byteranges.
         """Javascript"""                      draftprefix = (request_range is not None) and 'x-' or ''
           
         return file("../lib/python/Products/zogiLib/js/navigation.js").read()                      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
                           
     def generateTopJavaScript(self):                      # Do not keep the link references around.
         """generate script"""                      del pdata_map
         ret="""var baseUrl = '%s'; """% self.REQUEST['URL0']  
         ret+="""newParameter('fn', '%s', '', 1);  
                 newParameter('pn', '%s', '1', 1);  
                 newParameter('ws', '%s', '1.0', 1);  
                 newParameter('mo', '%s', '', 1);  
                 newParameter('mk', '%s', '', 3);  
                 newParameter('wx', '%s', '0.0', 2);  
                 newParameter('wy', '%s', '0.0', 2);  
                 newParameter('ww', '%s', '1.0', 2);  
                 newParameter('wh', '%s', '1.0', 2);  
                 newParameter('pt', '%s', '%s', 9);  
                 newParameter('brgt', '%s', '0.0', 1);  
                 newParameter('cont', '%s', '0.0', 1);  
                 newParameter('rot', '%s', '0.0', 1);  
                 newParameter('rgba', '%s', '', 1);  
                 newParameter('rgbm', '%s', '', 1);  
                 newParameter('ddpix', '%s', '', 9);  
                 newParameter('ddpiy', '%s', '', 9);"""%(getString(self,'fn'),  
                  getString(self,'pn',1),  
                  getString(self,'ws',1.0),  
                  getString(self,'mo',''),  
                  getString(self,'mk',''),  
                  getString(self,'wx',0.0),  
                  getString(self,'wy',0.0),  
                  getString(self,'ww',1.0),  
                  getString(self,'wh',1.0),  
                  getString(self,'pt',100),getString(self,'pt',100),  
                  getString(self,'brgt',0.0),  
                  getString(self,'cont',0.0),  
                  getString(self,'rot',0.0),  
                  getString(self,'rgba','0/0/0'),  
                  getString(self,'rgbm','0/0/0'),  
                  getString(self,'ddpix',0.0),  
                  getString(self,'ddpiy',0.0)  
                  )  
   
         ret+="""                      RESPONSE.write('\r\n--%s--\r\n' % boundary)
                       return ''
   
         var wwidth, wheight;          RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))
         if (self.innerHeight) // all except Explorer          RESPONSE.setHeader('Content-Type', self.content_type)
         {          RESPONSE.setHeader('Content-Length', self.size)
         wwidth = self.innerWidth;          RESPONSE.setHeader('Accept-Ranges', 'bytes')
         wheight = self.innerHeight;  
         }          # Don't cache the data itself, but provide an opportunity
         else if (document.documentElement && document.documentElement.clientHeight)          # for a cache manager to set response headers.
         // Explorer 6 Strict Mode          self.ZCacheable_set(None)
         {  
         wwidth = document.documentElement.clientWidth;          data=urllib.urlopen(self.baseUrl+self.queryString).read()
         wheight = document.documentElement.clientHeight;          
         }          if type(data) is type(''): 
         else if (document.body) // other Explorers              RESPONSE.setBase(None)
         {              return data
         wwidth = document.body.clientWidth;  
         wheight = document.body.clientHeight;          while data is not None:
         }              RESPONSE.write(data.data)
               data=data.next
   
         document.id="digilib"          return ''
                   
         """  
         return ret  
   
   def manage_addZogiImageForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
       return pt()
   
           
   def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
       """add dgilib"""
       newObj=zogiImage(id,title,baseUrl, queryString)
       self.Destination()._setObject(id,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
                                   
                                   
                   
   class zogiLib(Folder):
       """StandardElement"""
                   
     def generateScalerImg(self,requestString):      meta_type="zogiLib"
         """generate Scaler Tag"""  
         retStr=self.digilibBaseUrl+requestString  
         jS="""<script type="text/javascript">  
         document.write("<img id=\\\"pic\\\" src=\\\"%s&dw="+wwidth+"&dh="+wheight+"\\\"/>")</script>"""%retStr  
         return jS  
   
     def changeZogiLibForm(self):      manage_options = Folder.manage_options+(
         """Main configuration"""              {'label':'Main Config','action':'changeZogiLibForm'},
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)              )
         return pt()  
           
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):      def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):
         """change it"""          """init"""
   
           self.id=id
         self.title=title          self.title=title
         self.digilibBaseUrl=digilibBaseUrl          self.digilibBaseUrl=digilibBaseUrl
         self.localFileBase=localFileBase          self.localFileBase=localFileBase
           self.layout=version
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
       def getDLInfo(self):
           """get DLInfo from digilib server"""
           paramH={}
           baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)
           try:
               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:
               return null
                           
     def nav_html(self,fileName):  
         """navigations frame"""  
   
         # suche nach index.meta mit zogilib thumb info      def createHeadJS(self):
           """generate javascript tags for head"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
           return pt()
                           
       def createScalerImg(self, requestString = None):
           """generate Scaler IMG Tag"""
           bt = self.REQUEST.SESSION['browserType']
           if not requestString:
               requestString = self.REQUEST.QUERY_STRING
           url = self.digilibBaseUrl+requestString
           tag = ""
           if bt.isN4:
               tag += '<ilayer id="scaler">'
           else:
               tag += '<div id="scaler">'
           tag += '<script type="text/javascript">'
           tag += "var ps = bestPicSize(getElement('scaler'));"
           tag += 'document.write(\'<img id="pic" src="%s&dw=\'+ps.width+\'&dh=\'+ps.height+\'" />\')'%url
           tag += '</script>'
           if bt.isN4:
               tag += '</ilayer>'
           else:
               tag += '</div>'
           return tag
   
       def createAuxDiv(self):
           """generate other divs"""
           bt = self.REQUEST.SESSION['browserType']
           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):
           """option_js"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/option_js')).__of__(self)
           return pt()
   
       def dl_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/dl_lib.js', 'text/plain')
   
       def js_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/js_lib.js', 'text/plain')
   
       def optionwindow(self):
           """showoptions"""
           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')
                   
         templ=readNavTemp(self.localFileBase+"/"+fileName)  
         if not templ:  
             templ=readNavTemp(self.localFileBase+"/"+fileName.split("/")[0])  
             if not templ:  
                 return self.topTemplate.document_src()  
   
         return urllib.urlopen(templ).read()  
           
           
     def index_html(self):      def index_html(self):
         """main action"""          """main action"""
           tp = "zogiLibMainTemplate"
           if hasattr(self, tp):
           pt = getattr(self, tp)
           else:
               pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%self.layout)).__of__(self)
           return pt()
   
   
         pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_book.zpt').__of__(self)  
         return pt()  
   
     def storeQuery(self):      def storeQuery(self):
         """storeQuery in session"""          """storeQuery in session"""
         self.REQUEST.SESSION['query']={}          dlParams = {}
         for fm in self.REQUEST.form.keys():          for fm in self.REQUEST.form.keys():
             self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]              dlParams[fm] = self.REQUEST.form[fm]
   
           if 'mo' in dlParams:
               if len(dlParams['mo']) > 0:
                   modes=dlParams['mo'].split(',')
           else:
               modes=[]
   
         self.REQUEST.SESSION['dlInfo']=self.getDlInfo()          self.REQUEST.SESSION['query'] = dlParams
           self.REQUEST.SESSION['dlModes'] = modes
           self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()
           self.REQUEST.SESSION['browserType'] = BrowserCheck(self)
                   
     def getParam(self,param):          
         """Gebe Parameter aus"""      def getDLParam(self,param):
           """returns parameter"""
         try:          try:
             return self.REQUEST.SESSION['query'][param]              return self.REQUEST.SESSION['query'][param]
         except:          except:
             return None              return None
   
     def getPageNum(self):      def setDLParam(self, param, value):
         """PAgenum"""          """sets parameter"""
         pn=self.getParam('pn')          self.REQUEST.SESSION['query'][param] = value
         if pn:  
             return pn  
         else:  
             return 1  
   
     def biggerWS(self):  
         """ws+1"""  
         ws=self.getParam('ws')  
         if ws:  
             return int(ws)+1  
         else:  
             return 2  
   
     def options(self):  
         """showoptions"""  
         pt=PageTemplateFile('Products/zogiLib/zpt/optionwindow.zpt').__of__(self)  
         return pt()  
   
           
     def smallerWS(self):  
         """ws-11"""  
         ws=self.getParam('ws')  
         if ws:  
             if int(ws)==1:  
                 return                  return
             else:  
                 return int(ws)-1      def getAllDLParams(self):
         else:          """parameter string for digilib"""
             return 1          dlParams = self.REQUEST.SESSION['query']
           # save modes
           modes = self.REQUEST.SESSION['dlModes']
           dlParams['mo'] = string.join(modes, ',')
           # assemble query string
           ret = ""
           for param in dlParams.keys():
               val = str(dlParams[param])
               if val != "":
                   ret += param + "=" + val + "&"
           # omit trailing "&"
           return ret.rstrip('&')
                   
                   
     def setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
         """setze Parameter"""          """setze Parameter"""
         ret=""          ret=""
   
         if brgt:          if brgt:
             self.REQUEST.SESSION['query']['brgt']=brgt              self.setDLParam('brgt', brgt)
   
         if cont:          if cont:
             self.REQUEST.SESSION['query']['cont']=cont              self.setDLParam('cont', cont)
   
         if pn:          if pn:
             self.REQUEST.SESSION['query']['pn']=pn              self.setDLParam('pn', pn)
   
         if ws:          if ws:
             self.REQUEST.SESSION['query']['ws']=ws              self.setDLParam('ws', ws)
   
         if rot:          if rot:
             self.REQUEST.SESSION['query']['rot']=rot              self.setDLParam('rot', rot)
               
         for param in self.REQUEST.SESSION['query'].keys():  
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"          return self.display()
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
   
      
     def mirrorPage(self,mi):  
         """mirror"""  
         ret=""  
         try:  
             splitted=self.REQUEST.SESSION['query']['mo'].split(',')  
         except:  
             splitted=[]  
                   
         if mi=="h":      def display(self):
           """(re)display page"""
           params = self.getAllDLParams()
           self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
                                           
             if 'hmir' in splitted:      def getPT(self):
                 splitted.remove('hmir')          """pagenums"""
           di = self.REQUEST.SESSION['dlInfo']
           if di:
               return int(di['pt'])
             else:              else:
                 splitted.append('hmir')              return 1
   
         if mi=="v":  
   
             if 'vmir' in splitted:      def getPN(self):
                 splitted.remove('vmir')          """Pagenum"""
           pn = self.getDLParam('pn')
           if pn:
               return int(pn)
             else:              else:
                 splitted.append('vmir')              return 1
   
   
         self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")  
           
           
           
           
         for param in self.REQUEST.SESSION['query'].keys():  
               
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"  
           
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
           
     def decode(self,strR):  
         """decode &"""  
           
         return re.sub('\&amp','\&',strR)  
       
     def wholePage(self):  
         """zoom out"""  
         ret=""  
           
         self.REQUEST.SESSION['query']['ww']=1  
         self.REQUEST.SESSION['query']['wh']=1  
         self.REQUEST.SESSION['query']['wx']=0  
         self.REQUEST.SESSION['query']['wy']=0  
               
         for param in self.REQUEST.SESSION['query'].keys():  
               
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      def getBiggerWS(self):
           """ws+1"""
           ws=self.getDLParam('ws')
           if ws:
               return int(ws)+1
           else:
               return 2
                   
     def prevPage(self,pn=None):  
         """next page"""  
         ret=""  
   
         if pn and pn>0:      def getSmallerWS(self):
             pn=str(int(pn)-1)          """ws-1"""
           ws=self.getDLParam('ws')
           if ws:
               if int(ws)==1:
                   return 1
               else:
                   return int(ws)-1
           else:
               return 1
                   
       def hasMode(self, mode):
           """returns if mode is in the diglib mo parameter"""
           return (mode in self.REQUEST.SESSION['dlModes'])
   
       def hasNextPage(self):
           """returns if there is a next page"""
           pn = self.getPN()
           pt = self.getPT()
           return (pn < pt)
      
       def hasPrevPage(self):
           """returns if there is a previous page"""
           pn = self.getPN()
           return (pn > 1)
   
         self.REQUEST.form['pn']=pn  
                   
         for param in self.REQUEST.form.keys():  
                           
             ret+=param+"="+str(self.REQUEST.form[param])+"&"      def dl_HMirror(self):
           """mirror action"""
           modes = self.REQUEST.SESSION['dlModes']
           if 'hmir' in modes:
               modes.remove('hmir')
           else:
               modes.append('hmir')
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          return self.display()
   
     def firstPage(self):      def dl_VMirror(self):
         """erste Seite"""          """mirror action"""
         return self.setParam(pn="1")          modes = self.REQUEST.SESSION['dlModes']
           if 'vmir' in modes:
               modes.remove('vmir')
           else:
               modes.append('vmir')
           
     def lastPage(self):          return self.display()
         """letzte Seite"""  
   
       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 nextPage(self,pn=None):  
         """next page"""  
         ret=""  
                   
         try:  
             pn=str(int(pn)+1)  
         except:  
             pn=str(2)  
   
         self.REQUEST.form['pn']=pn      def changeZogiLibForm(self):
           """Main configuration"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
           return pt()
                   
         for param in self.REQUEST.form.keys():      def changeZogiLib(self,title,digilibBaseUrl, localFileBase, version, RESPONSE=None):
             ret+=param+"="+str(self.REQUEST.form[param])+"&"          """change it"""
           self.title=title
           self.digilibBaseUrl=digilibBaseUrl
           self.localFileBase=localFileBase
           self.layout=version
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
                   
 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,RESPONSE=None):  def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",RESPONSE=None):
     """add dgilib"""      """add dgilib"""
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase)      newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version)
     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')
Removed from v.1.3  
changed lines
  Added in v.1.18

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