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

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

version 1.38, 2004/07/23 16:01:28 version 1.58, 2005/10/11 20:06:05
Line 1 Line 1
   from OFS.SimpleItem import SimpleItem
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from OFS.Image import Image  from OFS.Image import Image
 from webdav.common import rfc1123_date  from AccessControl import ClassSecurityInfo
   
 import xml.dom.minidom  import xml.dom.minidom
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from xml_helpers import getUniqueElementText,getText  from xml_helpers import getUniqueElementText,getText
Line 11  import os Line 11  import os
 import re  import re
 import string  import string
 import urllib  import urllib
 import types  from types import *
   import random
   import cgi
 from Globals import package_home  from Globals import package_home
   
 ZOGIVERSION = "0.9.7 ROC:23.7.2004"  ZOGIVERSION = "0.9.15b DW:22.2.2005"
   
 def cropf(f):  def cropf(f):
     """returns a float with reduced precision"""      """returns a float with reduced precision"""
Line 22  def cropf(f): Line 24  def cropf(f):
   
   
 def sendFile(self, filename, type):  def sendFile(self, filename, type):
     """sends an object or a local file (in the product) as response"""      """sends an object or a local file (from the product) as response"""
     paths = filename.split('/')      paths = filename.split('/')
     object = self      object = self
     # look for an object called filename      # look for an object called filename
Line 47  def browserCheck(self): Line 49  def browserCheck(self):
     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 62  def browserCheck(self): Line 72  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 75  class zogiImage(Image): Line 85  class zogiImage(Image):
         """init"""          """init"""
         self.id=id          self.id=id
         self.title=title          self.title=title
           if baseUrl:
         self.baseUrl=baseUrl          self.baseUrl=baseUrl
           else:
               self.baseUrl="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?"
               
         self.queryString=queryString          self.queryString=queryString
         self.content_type=content_type          self.content_type=content_type
         self.precondition=precondition          self.precondition=precondition
   
     def getData(self):      #def getData(self):
         """getUrlData"""      #    """getUrlData"""
         return urllib.urlopen(self.baseUrl+self.queryString)      #    return urllib.urlopen(self.baseUrl+self.queryString)
   
     def changeZogiImageForm(self):      def changeZogiImageForm(self):
         """Main configuration"""          """Main configuration"""
Line 98  class zogiImage(Image): Line 112  class zogiImage(Image):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
           
     def index_html(self, REQUEST, RESPONSE):      def index_html(self, REQUEST, RESPONSE):
         """          """service the request by redirecting to digilib server"""
         Modified version of OFS/Image.py          RESPONSE.redirect(self.baseUrl+self.queryString)
           
         The default view of the contents of a File or Image.  
   
         Returns the contents of the file or image.  Also, sets the  
         Content-Type HTTP header to the objects content type.  
         """  
   
         # HTTP If-Modified-Since header handling.  
         header=REQUEST.get_header('If-Modified-Since', None)  
         if header is not None:  
             header=header.split( ';')[0]  
             # Some proxies seem to send invalid date strings for this  
             # header. If the date string is not valid, we ignore it  
             # rather than raise an error to be generally consistent  
             # with common servers such as Apache (which can usually  
             # understand the screwy date string as a lucky side effect  
             # of the way they parse it).  
             # This happens to be what RFC2616 tells us to do in the face of an  
             # invalid date.  
             try:    mod_since=long(DateTime(header).timeTime())  
             except: mod_since=None  
             if mod_since is not None:  
                 if self._p_mtime:  
                     last_mod = long(self._p_mtime)  
                 else:  
                     last_mod = long(0)  
                 if last_mod > 0 and last_mod <= mod_since:  
                     # Set header values since apache caching will return Content-Length  
                     # of 0 in response if size is not set here  
                     RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', self.size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     self.ZCacheable_set(None)  
                     RESPONSE.setStatus(304)  
                     return ''  
   
         if self.precondition and hasattr(self,self.precondition):  
             # Grab whatever precondition was defined and then  
             # execute it.  The precondition will raise an exception  
             # if something violates its terms.  
             c=getattr(self,self.precondition)  
             if hasattr(c,'isDocTemp') and c.isDocTemp:  
                 c(REQUEST['PARENTS'][1],REQUEST)  
             else:  
                 c()  
   
         # HTTP Range header handling  
         range = REQUEST.get_header('Range', None)  
         request_range = REQUEST.get_header('Request-Range', None)  
         if request_range is not None:  
             # Netscape 2 through 4 and MSIE 3 implement a draft version  
             # Later on, we need to serve a different mime-type as well.  
             range = request_range  
         if_range = REQUEST.get_header('If-Range', None)  
         if range is not None:  
             ranges = HTTPRangeSupport.parseRange(range)  
   
             if if_range is not None:  
                 # Only send ranges if the data isn't modified, otherwise send  
                 # the whole object. Support both ETags and Last-Modified dates!  
                 if len(if_range) > 1 and if_range[:2] == 'ts':  
                     # ETag:  
                     if if_range != self.http__etag():  
                         # Modified, so send a normal response. We delete  
                         # the ranges, which causes us to skip to the 200  
                         # response.  
                         ranges = None  
                 else:  
                     # Date  
                     date = if_range.split( ';')[0]  
                     try: mod_since=long(DateTime(date).timeTime())  
                     except: mod_since=None  
                     if mod_since is not None:  
                         if self._p_mtime:  
                             last_mod = long(self._p_mtime)  
                         else:  
                             last_mod = long(0)  
                         if last_mod > mod_since:  
                             # Modified, so send a normal response. We delete  
                             # the ranges, which causes us to skip to the 200  
                             # response.  
                             ranges = None  
   
             if ranges:  
                 # Search for satisfiable ranges.  
                 satisfiable = 0  
                 for start, end in ranges:  
                     if start < self.size:  
                         satisfiable = 1  
                         break  
   
                 if not satisfiable:  
                     RESPONSE.setHeader('Content-Range',  
                         'bytes */%d' % self.size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', self.size)  
                     RESPONSE.setStatus(416)  
                     return ''  
   
                 ranges = HTTPRangeSupport.expandRanges(ranges, self.size)  
                                   
                 if len(ranges) == 1:  
                     # Easy case, set extra header and return partial set.  
                     start, end = ranges[0]  
                     size = end - start  
   
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type', self.content_type)  
                     RESPONSE.setHeader('Content-Length', size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Content-Range',  
                         'bytes %d-%d/%d' % (start, end - 1, self.size))  
                     RESPONSE.setStatus(206) # Partial content  
   
                     data = urllib.urlopen(self.baseUrl+self.queryString).read()  
                     if type(data) is StringType:  
                         return data[start:end]  
   
                     # Linked Pdata objects. Urgh.  
                     pos = 0  
                     while data is not None:  
                         l = len(data.data)  
                         pos = pos + l  
                         if pos > start:  
                             # We are within the range  
                             lstart = l - (pos - start)  
   
                             if lstart < 0: lstart = 0  
   
                             # find the endpoint  
                             if end <= pos:  
                                 lend = l - (pos - end)  
   
                                 # Send and end transmission  
                                 RESPONSE.write(data[lstart:lend])  
                                 break  
   
                             # Not yet at the end, transmit what we have.  
                             RESPONSE.write(data[lstart:])  
   
                         data = data.next  
   
                     return ''  
   
                 else:  
                     boundary = choose_boundary()  
   
                     # Calculate the content length  
                     size = (8 + len(boundary) + # End marker length  
                         len(ranges) * (         # Constant lenght per set  
                             49 + len(boundary) + len(self.content_type) +  
                             len('%d' % self.size)))  
                     for start, end in ranges:  
                         # Variable length per set  
                         size = (size + len('%d%d' % (start, end - 1)) +  
                             end - start)  
   
   
                     # Some clients implement an earlier draft of the spec, they  
                     # will only accept x-byteranges.  
                     draftprefix = (request_range is not None) and 'x-' or ''  
   
                     RESPONSE.setHeader('Content-Length', size)  
                     RESPONSE.setHeader('Accept-Ranges', 'bytes')  
                     RESPONSE.setHeader('Last-Modified',  
                         rfc1123_date(self._p_mtime))  
                     RESPONSE.setHeader('Content-Type',  
                         'multipart/%sbyteranges; boundary=%s' % (  
                             draftprefix, boundary))  
                     RESPONSE.setStatus(206) # Partial content  
   
                     data = urllib.urlopen(self.baseUrl+self.queryString).read()  
                     # The Pdata map allows us to jump into the Pdata chain  
                     # arbitrarily during out-of-order range searching.  
                     pdata_map = {}  
                     pdata_map[0] = data  
   
                     for start, end in ranges:  
                         RESPONSE.write('\r\n--%s\r\n' % boundary)  
                         RESPONSE.write('Content-Type: %s\r\n' %  
                             self.content_type)  
                         RESPONSE.write(  
                             'Content-Range: bytes %d-%d/%d\r\n\r\n' % (  
                                 start, end - 1, self.size))  
   
                         if type(data) is StringType:  
                             RESPONSE.write(data[start:end])  
   
                         else:  
                             # Yippee. Linked Pdata objects. The following  
                             # calculations allow us to fast-forward through the  
                             # Pdata chain without a lot of dereferencing if we  
                             # did the work already.  
                             first_size = len(pdata_map[0].data)  
                             if start < first_size:  
                                 closest_pos = 0  
                             else:  
                                 closest_pos = (  
                                     ((start - first_size) >> 16 << 16) +  
                                     first_size)  
                             pos = min(closest_pos, max(pdata_map.keys()))  
                             data = pdata_map[pos]  
   
                             while data is not None:  
                                 l = len(data.data)  
                                 pos = pos + l  
                                 if pos > start:  
                                     # We are within the range  
                                     lstart = l - (pos - start)  
   
                                     if lstart < 0: lstart = 0  
   
                                     # find the endpoint  
                                     if end <= pos:  
                                         lend = l - (pos - end)  
   
                                         # Send and loop to next range  
                                         RESPONSE.write(data[lstart:lend])  
                                         break  
   
                                     # Not yet at the end, transmit what we have.  
                                     RESPONSE.write(data[lstart:])  
   
                                 data = data.next  
                                 # Store a reference to a Pdata chain link so we  
                                 # don't have to deref during this request again.  
                                 pdata_map[pos] = data  
   
                     # Do not keep the link references around.  
                     del pdata_map  
   
                     RESPONSE.write('\r\n--%s--\r\n' % boundary)  
                     return ''  
   
         RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))  
         RESPONSE.setHeader('Content-Type', self.content_type)  
         RESPONSE.setHeader('Content-Length', self.size)  
         RESPONSE.setHeader('Accept-Ranges', 'bytes')  
   
         # Don't cache the data itself, but provide an opportunity  
         # for a cache manager to set response headers.  
         self.ZCacheable_set(None)  
   
         data=urllib.urlopen(self.baseUrl+self.queryString).read()  
           
         if type(data) is type(''):   
             RESPONSE.setBase(None)  
             return data  
   
         while data is not None:  
             RESPONSE.write(data.data)  
             data=data.next  
   
         return ''          return ''
   
       def rescale(self,width=None,height=None):
           """andere parameter im querystring"""
           qs=cgi.parse_qs(self.queryString)
           for x in qs.keys():
               if type(qs[x]) is ListType:
                   qs[x]=qs[x][0]
           
           if width:
               qs['dw']=width
           if height:
               qs['dh']=height
   
           
           qsneu=urllib.urlencode(qs)
           self.queryString=qsneu
           return "done"
   
 def manage_addZogiImageForm(self):  def manage_addZogiImageForm(self):
     """Form for adding"""      """Form for adding"""
Line 370  def manage_addZogiImageForm(self): Line 141  def manage_addZogiImageForm(self):
   
   
 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 379  def manage_addZogiImage(self,id,title,ba Line 150  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 396  class zogiLib(Folder): Line 168  class zogiLib(Folder):
         self.dlServerURL = dlServerURL          self.dlServerURL = dlServerURL
         self.basePath=basePath          self.basePath=basePath
         self.layout=layout          self.layout=layout
         if dlTarget:  
             self.dlTarget = dlTarget              self.dlTarget = dlTarget
         else:  
             self.dlTarget = "digilib"  
   
         if dlToolbarBaseURL:          if dlToolbarBaseURL:
             self.dlToolbarBaseURL = dlToolbarBaseURL              self.dlToolbarBaseURL = dlToolbarBaseURL
         else:          else:
             self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"              self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
       security.declareProtected('View','getLayout')
       def getLayout(self):
           """get Layout"""
           return self.layout
   
     def version(self):      def version(self):
         """version information"""          """version information"""
Line 452  class zogiLib(Folder): Line 225  class zogiLib(Folder):
   
             return ret              return ret
         except:          except:
             return ret  
   
     def formatHTML(self,url,label=None,viewUrl=None):              return []
   
   
       def formatHTML(self,url,label=None,viewUrl=None):
   
         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
Line 475  class zogiLib(Folder): Line 249  class zogiLib(Folder):
             ret+="</table>"              ret+="</table>"
         return ret          return ret
           
       
     def getMetaData(self):      def getMetaData(self):
         """getMetaData"""          """getMetaData"""
         try:          try:
Line 521  class zogiLib(Folder): Line 296  class zogiLib(Folder):
                     return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)                      return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
         return ret          return ret
   
   
     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.dlServerURL+"/dlInfo-xml.jsp"
         try:          try:
             url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])              url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING'])
             dom=xml.dom.minidom.parse(url)              dom=xml.dom.minidom.parse(url)
             params=dom.getElementsByTagName('parameter')              params=dom.getElementsByTagName('parameter')
             for param in params:              for param in params:
Line 539  class zogiLib(Folder): Line 315  class zogiLib(Folder):
     def createHeadJS(self):      def createHeadJS(self):
         """generate all javascript tags for head"""          """generate all javascript tags for head"""
     self.checkQuery()      self.checkQuery()
     bt = self.REQUEST.SESSION['browserType']          bt = self.REQUEST.SESSION.get('browserType', {})
         if bt['staticHTML']:          if bt['staticHTML']:
             return              return
                   
Line 557  class zogiLib(Folder): Line 333  class zogiLib(Folder):
         return pt()          return pt()
                   
                                                   
       def getScalerUrl(self,requestString=None):
           """send scaler url"""
           if requestString:
               return self.dlServerURL+'/servlet/Scaler?'+requestString
           else:
               return self.dlServerURL+'/servlet/Scaler?'
       
       def scaledImage(self,requestString=None):
           """scaled Image"""
           
           if not requestString:
               requestString=self.REQUEST['QUERY_STRING']
               
           self.REQUEST.RESPONSE.redirect(self.getScalerUrl(requestString))
           
           return True
       
           
     def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):      def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
         """generate Scaler IMG Tag"""          """generate Scaler IMG Tag"""
     self.checkQuery()      self.checkQuery()
Line 616  class zogiLib(Folder): Line 410  class zogiLib(Folder):
         if bt['isN4']:          if bt['isN4']:
             f = 'zpt/zogilib_divsN4.zpt'              f = 'zpt/zogilib_divsN4.zpt'
         else:          else:
             f = 'zpt/zogilib_divs.zpt'              f = 'zpt/zogiLib_divs.zpt'
         pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self)
         return pt()          return pt()
   
Line 636  class zogiLib(Folder): Line 430  class zogiLib(Folder):
     def optionwindow(self):      def optionwindow(self):
         """showoptions"""          """showoptions"""
     self.checkQuery()      self.checkQuery()
         if self.REQUEST.has_key('frametarget'):  
             self.dlTarget = self.REQUEST['frametarget']  
     bt = self.REQUEST.SESSION['browserType']      bt = self.REQUEST.SESSION['browserType']
         if bt['staticHTML']:          if bt['staticHTML']:
             pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
Line 735  class zogiLib(Folder): Line 527  class zogiLib(Folder):
         return pt()          return pt()
   
   
   
     def storeQuery(self, more = None):      def storeQuery(self, more = None):
         """storeQuery in session"""          """storeQuery in session"""
         dlParams = {}          dlParams = {}
Line 757  class zogiLib(Folder): Line 548  class zogiLib(Folder):
         else:          else:
             modes=[]              modes=[]
   
         self.REQUEST.SESSION['query'] = dlParams          wid = self.getWID()
         self.REQUEST.SESSION['dlModes'] = modes          self.REQUEST.set('wid', wid)
         self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()          self.setSubSession('dlQuery', dlParams)
           self.setSubSession('dlModes', modes)
           self.setSubSession('dlInfo', self.getDLInfo())
         if not self.REQUEST.SESSION.has_key('browserType'):          if not self.REQUEST.SESSION.has_key('browserType'):
             self.REQUEST.SESSION['browserType'] = browserCheck(self)              self.REQUEST.SESSION['browserType'] = browserCheck(self)
                           
Line 767  class zogiLib(Folder): Line 560  class zogiLib(Folder):
   
     def checkQuery(self):      def checkQuery(self):
     """check if the query has been stored"""      """check if the query has been stored"""
     if not (self.REQUEST.SESSION and self.REQUEST.SESSION.has_key('query')) :          if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) :
         print "ZOGILIB: have to store query!!"          print "ZOGILIB: have to store query!!"
         self.storeQuery()          self.storeQuery()
         return          return
Line 787  class zogiLib(Folder): Line 580  class zogiLib(Folder):
             url += '/'              url += '/'
         return url          return url
                   
     def getDLParam(self, param):      def zogilibAction(self, action, otherbase=None, wid=None):
         """returns parameter"""          """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
   
       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, default=None):
           """returns parameter or default"""
         try:          try:
             return self.REQUEST.SESSION['query'][param]              return self.getSubSession('dlQuery').get(param, default)
         except:          except:
             return              return default
   
     def setDLParam(self, param, value):      def setDLParam(self, param, value):
         """sets parameter"""          """sets parameter"""
         self.REQUEST.SESSION['query'][param] = value          dlParams = self.getSubSession('dlQuery')
           #try:
           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.REQUEST.SESSION['query']          dlParams = self.getSubSession('dlQuery')
         # save modes          # save modes
         modes = self.REQUEST.SESSION['dlModes']          modes = self.getSubSession('dlModes')
         dlParams['mo'] = string.join(modes, ',')          dlParams['mo'] = string.join(modes, ',')
         # assemble query string          # assemble query string
         ret = ""          ret = ""
Line 835  class zogiLib(Folder): Line 661  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:
             self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)              self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
         else:          else:
Line 854  class zogiLib(Folder): Line 685  class zogiLib(Folder):
         """returns dlTarget"""          """returns dlTarget"""
         self.checkQuery()          self.checkQuery()
         s = self.dlTarget          s = self.dlTarget
           if s == None:
               s = ""
 #         s = 'dl'  #         s = 'dl'
 #         if self.getDLParam('fn'):  #         if self.getDLParam('fn'):
 #             s += "_" + self.getDLParam('fn')  #             s += "_" + self.getDLParam('fn')
Line 874  class zogiLib(Folder): Line 707  class zogiLib(Folder):
   
     def getPT(self):      def getPT(self):
         """pagenums"""          """pagenums"""
         di = self.REQUEST.SESSION['dlInfo']          di = self.getSubSession('dlInfo')
         if di:          if di:
             return int(di['pt'])              return int(di['pt'])
         else:          else:
Line 906  class zogiLib(Folder): Line 739  class zogiLib(Folder):
   
     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"""
         return (mode in self.REQUEST.SESSION['dlModes'])          wid = self.getWID()
           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 956  class zogiLib(Folder): Line 790  class zogiLib(Folder):
                   
     def dl_HMirror(self):      def dl_HMirror(self):
         """mirror action"""          """mirror action"""
         modes = self.REQUEST.SESSION['dlModes']          modes = self.getSubSession('dlModes')
         if 'hmir' in modes:          if 'hmir' in modes:
             modes.remove('hmir')              modes.remove('hmir')
         else:          else:
Line 966  class zogiLib(Folder): Line 800  class zogiLib(Folder):
                 
     def dl_VMirror(self):      def dl_VMirror(self):
         """mirror action"""          """mirror action"""
         modes = self.REQUEST.SESSION['dlModes']          modes = self.getSubSession('dlModes')
         if 'vmir' in modes:          if 'vmir' in modes:
             modes.remove('vmir')              modes.remove('vmir')
         else:          else:
Line 1103  class zogiLib(Folder): Line 937  class zogiLib(Folder):
         self.dlServerURL=dlServerURL          self.dlServerURL=dlServerURL
         self.basePath = basePath          self.basePath = basePath
         self.layout=version          self.layout=version
         if dlTarget:  
             self.dlTarget = dlTarget              self.dlTarget = dlTarget
         else:  
             self.dlTarget = "digilib"  
   
         if dlToolbarBaseURL:          if dlToolbarBaseURL:
             self.dlToolbarBaseURL = dlToolbarBaseURL              self.dlToolbarBaseURL = dlToolbarBaseURL
Line 1119  class zogiLib(Folder): Line 950  class zogiLib(Folder):
   
   
     ##      ##
     ## odd stuff      ## odds and ends
     ##      ##
   
     def repairZogilib(self, obj=None):      def repairZogilib(self, obj=None):
Line 1157  def manage_addZogiLibForm(self): Line 988  def manage_addZogiLibForm(self):
     pt=PageTemplateFile(os.path.join(package_home(globals()), '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,dlServerURL,layout="book",basePath="",dlTarget="digilib",dlToolbarBaseURL=None,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,dlServerURL, localFileBase, version, basePath, dlTarget, dlToolbarBaseURL)      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')
Removed from v.1.38  
changed lines
  Added in v.1.58

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