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

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

version 1.1, 2004/03/25 18:07:37 version 1.7, 2004/04/16 14:07:08
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 56  class zogiLib_navTemplate(ZopePageTempla Line 57  class zogiLib_navTemplate(ZopePageTempla
           
 def manage_addZogiLib_NavTemplateForm(self):  def manage_addZogiLib_NavTemplateForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddZogilib_NavTemplate.zpt').__of__(self)      pt=PageTemplateFile('Products/zogiLib/zpt/AddZogilib_NavTemplate.zpt').__of__(self)
     return pt()      return pt()
   
   
Line 97  def manage_addZogiLib_NavTemplate(self, Line 98  def manage_addZogiLib_NavTemplate(self,
         REQUEST.RESPONSE.redirect(u+'/manage_main')          REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
   
   
           
 def readNavTemp(fileName):  def readNavTemp(fileName):
     """navtemp"""      """navtemp"""
     print "HI reading",fileName      
           
     if os.path.exists(fileName+"/index.meta"):      if os.path.exists(fileName+"/index.meta"):
         dom=xml.dom.minidom.parse(fileName+"/index.meta")          dom=xml.dom.minidom.parse(fileName+"/index.meta")
     else:      else:
         return None          return None
           
     print "dom",dom      
     try:      try:
         navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)          navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)
     except:      except:
         navTag=None          navTag=None
     return navTag      return navTag
           
   class zogiLib_mainTemplate(ZopePageTemplate):
       """pageTemplate Objekt"""
       meta_type="zogiLib_mainTemplate"
   
       
       def __init__(self, id, text=None, content_type=None, version="book"):
   
           default_content_string="zpt/zogiLibMain_%s.zpt"%version
           self._default_content_fn = os.path.join(package_home(globals()),default_content_string)
           self.id = str(id)
           self.ZBindings_edit(self._default_bindings)
           if text is None:
               text = open(self._default_content_fn).read()
           self.pt_edit(text, content_type)
   
       
   def manage_addZogiLibMainTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile('Products/ECHO_content/zpt/AddOSAS_thumbTemplate.zpt').__of__(self)
       return pt()
   
   
   
   
   def manage_addZogiLibMainTemplate(self, id,title=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
   
       
       id = str(id)
       if REQUEST is None:
           self._setObject(id, zogiLib_mainTemplate(id, text))
           ob = getattr(self, id)
          
           if title:
               ob.pt_setTitle(title)
           return ob
       else:
           file = REQUEST.form.get('file')
           headers = getattr(file, 'headers', None)
           if headers is None or not file.filename:
               zpt = zogiLib_mainTemplate(id)
           else:
               zpt = zogiLib_mainTemplate(id, file, headers.get('content_type'))
   
           self._setObject(id, zpt)
           ob = getattr(self, id)
   
   
           try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
           if submit == " Add and Edit ":
               u = "%s/%s" % (u, quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
       
   class zogiImage(Image):
       """einzelnes Image"""
       meta_type="zogiImage"
   
       
       
       def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
           """init"""
           self.id=id
           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('Products/zogiLib/zpt/changeZogiImageForm.zpt').__of__(self)
           return pt()
       
       def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):
           """change it"""
           self.title=title
           self.baseUrl=baseUrl
           self.queryString=queryString
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       manage_options=ZopePageTemplate.manage_options+(
           {'label':'Main config','action':'changeZogiImageForm'},
          )
   
       
   
           
       def index_html(self, REQUEST, RESPONSE):
           """
           Modified version of OFS/Image.py
           
           The default view of the contents of a File or Image.
   
           Returns the contents of the file or image.  Also, sets the
           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 ''
   
   
   def manage_addZogiImageForm(self):
       """Form for adding"""
       pt=PageTemplateFile('Products/zogiLib/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):  class zogiLib(Folder):
     """StandardElement"""      """StandardElement"""
   
     meta_type="zogiLib"      meta_type="zogiLib"
   
       def getDlInfo(self):
           """DLInfo"""
           paramH={}
           baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)
           
           url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])
           dom=xml.dom.minidom.parse(url)
           params=dom.getElementsByTagName('parameter')
           for param in params:
               paramH[param.getAttribute('name')]=param.getAttribute('value')
           return paramH
   
       def getPageNumTotal(self):
           """pagenums"""
           return self.getDlInfo()['pt']
       
       
     def generateImageFolder(self):      def generateImageFolder(self):
         """images ablegen"""          """images ablegen"""
         self.manage_addFolder('images')          self.manage_addFolder('images')
         for image in os.listdir("../lib/python/Products/zogiLib/images"):          pathName=os.path.join(package_home(globals()),'images')
             fn=file("../lib/python/Products/zogiLib/images/"+image)          for image in os.listdir(pathName):
             print fn              try:
                   
                   fn=file(os.path.join(pathName,image))
             self.images.manage_addImage(image,fn)              self.images.manage_addImage(image,fn)
               except:
                   print "ZOGILIB not imported:",image
                   
                   
   
     def __init__(self, id,title,zogilibBaseUrl, localFileBase):  
       def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):
         """init"""          """init"""
   
         self.id=id          self.id=id
         self.title=title          self.title=title
         self.zogilibBaseUrl=zogilibBaseUrl          self.digilibBaseUrl=digilibBaseUrl
         self.localFileBase=localFileBase          self.localFileBase=localFileBase
         self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))          #self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))
           self._setObject('mainTemplate',zogiLib_mainTemplate(id='mainTemplate',version=version))
         self.generateImageFolder()          self.generateImageFolder()
   
   
Line 143  class zogiLib(Folder): Line 549  class zogiLib(Folder):
             {'label':'Main Config','action':'changeZogiLibForm'},              {'label':'Main Config','action':'changeZogiLibForm'},
             )              )
   
       def option_js(self):
           """option_js"""
           ret="""function setDLParam(e) {
             if (document.all) {
               s=e.srcElement;
             } else {
               s=e.target;
             }
             if (window.opener) {
               window.opener.setParameter(s.name, s.value);
               window.opener.display(9);
             } else {
               document.setParameter(s.name, s.value);
               document.display(9);
             }
           }"""
           return ret
                           
                           
     def navigation_js(self):      def navigation_js(self):
         """Javascript"""          """Javascript"""
           fileName=os.path.join(package_home(globals()),'js/navigation.js')
           return file(fileName).read()
                   
         return file("../lib/python/Products/zogiLib/js/navigation.js").read()  
   
                           
     def generateTopJavaScript(self):      def generateTopJavaScript(self):
         """generate script"""          """generate script"""
         ret="""var baseUrl = '%s'; """% self.REQUEST['URL0']          ret="""
         ret+="""newParameter('fn', '%s', '', 1);          var baseUrl = '%s'; """% self.REQUEST['URL0']
                 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+="""          ret+="""
           newParameter('fn', '', 1);
         var wwidth, wheight;          newParameter('pn', '1', 1);
         if (self.innerHeight) // all except Explorer          newParameter('ws', '1.0', 1);
         {          newParameter('mo', '', 1);
         wwidth = self.innerWidth;          newParameter('mk', '', 3);
         wheight = self.innerHeight;          newParameter('wx', '0.0', 2);
         }          newParameter('wy', '0.0', 2);
         else if (document.documentElement && document.documentElement.clientHeight)          newParameter('ww', '1.0', 2);
         // Explorer 6 Strict Mode          newParameter('wh', '1.0', 2);
         {          newParameter('pt', '0', 9);
         wwidth = document.documentElement.clientWidth;          newParameter('brgt', '0.0', 1);
         wheight = document.documentElement.clientHeight;          newParameter('cont', '0.0', 1);
         }          newParameter('rot', '0.0', 1);
         else if (document.body) // other Explorers          newParameter('rgba', '', 1);
         {          newParameter('rgbm', '', 1);
         wwidth = document.body.clientWidth;          newParameter('ddpix', '', 9);
         wheight = document.body.clientHeight;          newParameter('ddpiy', '', 9);
         }          var picsize = new Size(100, 100);
           document.id='digilib';
           
         """          """
         return ret          return ret
   
   
       
                   
                   
           
           
     def generateScalerImg(self,requestString):      def generateScalerImg(self,requestString):
         """generate Scaler Tag"""          """generate Scaler IMG Tag"""
         retStr=self.zogilibBaseUrl+requestString          retStr=self.digilibBaseUrl+requestString
         jS="""<script type="text/javascript">          jS="""<script type="text/javascript">picsize = bestPicSize('scaler');
         document.write("<img id=\\\"pic\\\" src=\\\"%s&dw="+wwidth+"&dh="+wheight+"\\\"/>")</script>"""%retStr          document.write('<img id="pic" src="%s&dw='+picsize.width+'&dh='+picsize.height+'" />')
           </script>"""%retStr
         return jS          return jS
   
     def changeZogiLibForm(self):      def changeZogiLibForm(self):
Line 229  class zogiLib(Folder): Line 616  class zogiLib(Folder):
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)          pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)
         return pt()          return pt()
           
     def changeZogiLib(self,title,zogilibBaseUrl, localFileBase,RESPONSE=None):      def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):
         """change it"""          """change it"""
         self.title=title          self.title=title
         self.zogilibBaseUrl=zogilibBaseUrl          self.digilibBaseUrl=digilibBaseUrl
         self.localFileBase=localFileBase          self.localFileBase=localFileBase
   
         if RESPONSE is not None:          if RESPONSE is not None:
Line 241  class zogiLib(Folder): Line 628  class zogiLib(Folder):
                           
     def nav_html(self,fileName):      def nav_html(self,fileName):
         """navigations frame"""          """navigations frame"""
           ## currently not in use
         # suche nach index.meta mit zogilib thumb info          # suche nach index.meta mit zogilib thumb info
                   
         templ=readNavTemp(self.localFileBase+"/"+fileName)          templ=readNavTemp(self.localFileBase+"/"+fileName)
Line 257  class zogiLib(Folder): Line 644  class zogiLib(Folder):
         """main action"""          """main action"""
   
   
         pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain.zpt').__of__(self)          #pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_image.zpt').__of__(self)
         return pt()          #return pt()
           return self.mainTemplate()
   
     def storeQuery(self):      def storeQuery(self):
         """storeQuery in session"""          """storeQuery in session"""
Line 266  class zogiLib(Folder): Line 654  class zogiLib(Folder):
         for fm in self.REQUEST.form.keys():          for fm in self.REQUEST.form.keys():
             self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]              self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]
   
     def setParam(self,pn=None,ws=None,rot=None):          self.REQUEST.SESSION['dlInfo']=self.getDlInfo()
         """gotopage"""          
       def getParam(self,param):
           """Gebe Parameter aus"""
           try:
               return self.REQUEST.SESSION['query'][param]
           except:
               return None
   
       def getPageNum(self):
           """PAgenum"""
           pn=self.getParam('pn')
           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
               else:
                   return int(ws)-1
           else:
               return 1
           
           
       def setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
           """setze Parameter"""
         ret=""          ret=""
   
           if brgt:
               self.REQUEST.SESSION['query']['brgt']=brgt
   
           if cont:
               self.REQUEST.SESSION['query']['cont']=cont
   
         if pn:          if pn:
             self.REQUEST.SESSION['query']['pn']=pn              self.REQUEST.SESSION['query']['pn']=pn
   
Line 285  class zogiLib(Folder): Line 722  class zogiLib(Folder):
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)
   
      
     def mirrorPage(self,mi):      def mirrorPage(self,mi):
         """mirror"""          """mirror"""
         ret=""          ret=""
Line 321  class zogiLib(Folder): Line 759  class zogiLib(Folder):
                   
     def decode(self,strR):      def decode(self,strR):
         """decode &"""          """decode &"""
         print re.sub('\&amp','\&',strR)          
         return re.sub('\&amp','\&',strR)          return re.sub('\&amp','\&',strR)
           
     def wholePage(self):      def wholePage(self):
Line 348  class zogiLib(Folder): Line 786  class zogiLib(Folder):
                   
   
         self.REQUEST.form['pn']=pn          self.REQUEST.form['pn']=pn
         print "hi",self.REQUEST.form.keys()          
         for param in self.REQUEST.form.keys():          for param in self.REQUEST.form.keys():
             print param              
             ret+=param+"="+str(self.REQUEST.form[param])+"&"              ret+=param+"="+str(self.REQUEST.form[param])+"&"
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)
   
       def firstPage(self):
           """erste Seite"""
           return self.setParam(pn="1")
       
       def lastPage(self):
           """letzte Seite"""
   
           
     def nextPage(self,pn=None):      def nextPage(self,pn=None):
         """next page"""          """next page"""
Line 366  class zogiLib(Folder): Line 811  class zogiLib(Folder):
             pn=str(2)              pn=str(2)
   
         self.REQUEST.form['pn']=pn          self.REQUEST.form['pn']=pn
         print "hi",self.REQUEST.form.keys()          
         for param in self.REQUEST.form.keys():          for param in self.REQUEST.form.keys():
             print param  
             ret+=param+"="+str(self.REQUEST.form[param])+"&"              ret+=param+"="+str(self.REQUEST.form[param])+"&"
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)
Line 379  def manage_addZogiLibForm(self): Line 823  def manage_addZogiLibForm(self):
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiLibForm').__of__(self)      pt=PageTemplateFile('Products/zogiLib/zpt/addZogiLibForm').__of__(self)
     return pt()      return pt()
   
 def manage_addZogiLib(self,id,title,zogilibBaseUrl, localFileBase,RESPONSE=None):  def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",RESPONSE=None):
     """add dgilib"""      """add dgilib"""
     newObj=zogiLib(id,title,zogilibBaseUrl, 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.1  
changed lines
  Added in v.1.7

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