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

Diff for /documentViewer/documentViewer.py between versions 1.3 and 1.10.2.1

version 1.3, 2006/04/06 17:13:43 version 1.10.2.1, 2006/06/13 14:57:46
Line 1 Line 1
   
 genericDigilib="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/"  
   
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
   from AccessControl import getSecurityManager
 from Globals import package_home  from Globals import package_home
   
 from Ft.Xml.Domlette import NonvalidatingReader  from Ft.Xml.Domlette import NonvalidatingReader
Line 14  from Ft.Xml import EMPTY_NAMESPACE Line 12  from Ft.Xml import EMPTY_NAMESPACE
 import Ft.Xml.XPath  import Ft.Xml.XPath
   
 import os.path  import os.path
   import sys
 import cgi  import cgi
 import urllib  import urllib
 import zLOG  import zLOG
   
   def getInt(number, default=0):
       """returns always an int (0 in case of problems)"""
       try:
           return int(number)
       except:
           return default
   
 def getTextFromNode(nodename):  def getTextFromNode(nodename):
       if nodename is None:
           return ""
     nodelist=nodename.childNodes      nodelist=nodename.childNodes
     rc = ""      rc = ""
     for node in nodelist:      for node in nodelist:
Line 26  def getTextFromNode(nodename): Line 34  def getTextFromNode(nodename):
            rc = rc + node.data             rc = rc + node.data
     return rc      return rc
   
           
   def getParentDir(path):
       """returns pathname shortened by one"""
       return '/'.join(path.split('/')[0:-1])
           
   
 import socket  import socket
   
 def urlopen(url):  def urlopen(url,timeout=2):
         """urlopen mit timeout"""          """urlopen mit timeout"""
         socket.setdefaulttimeout(2)          socket.setdefaulttimeout(timeout)
         ret=urllib.urlopen(url)          ret=urllib.urlopen(url)
         socket.setdefaulttimeout(5)          socket.setdefaulttimeout(5)
         return ret          return ret
           
 def getParamFromDigilib(path,param):  
     """gibt param von dlInfo aus"""  
     imageUrl=genericDigilib+"/dirInfo-xml.jsp?mo=dir&fn="+path  
   
     zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo (%s) from %s"%(param,imageUrl))  
       
     try:  
         dom = NonvalidatingReader.parseUri(imageUrl)  
     except:  
         return None  
       
     params=dom.xpath("//dir/%s"%param)  
     zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo:%s"%params)  
       
     if params:  
         return getTextFromNode(params[0])  
   
       
   
   
 ##  ##
 ## documentViewer class  ## documentViewer class
Line 79  class documentViewer(Folder): Line 74  class documentViewer(Folder):
     changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())      changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
   
           
     def __init__(self,id,imageViewerUrl,title="",digilibBaseUrl=None):      def __init__(self,id,imageViewerUrl,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=10,authgroups="mpiwg"):
         """init document viewer"""          """init document viewer"""
         self.id=id          self.id=id
         self.title=title          self.title=title
         self.imageViewerUrl=imageViewerUrl          self.imageViewerUrl=imageViewerUrl
         self.digilibBaseUrl = digilibBaseUrl          if not digilibBaseUrl:
         if not self.digilibBaseUrl:  
             self.digilibBaseUrl = self.findDigilibUrl()              self.digilibBaseUrl = self.findDigilibUrl()
           else:
               self.digilibBaseUrl = digilibBaseUrl
           self.thumbcols = thumbcols
           self.thumbrows = thumbrows
           # authgroups is list of authorized groups (delimited by ,)
           self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
         # add template folder so we can always use template.something          # add template folder so we can always use template.something
         self.manage_addFolder('template')          self.manage_addFolder('template')
   
   
     security.declareProtected('View','index_html')      security.declareProtected('View','index_html')
     def index_html(self,mode,url,start=0,pn=1):      def index_html(self,mode,url,start=None,pn=1):
         '''          '''
         view it          view it
         @param mode: defines which type of document is behind url          @param mode: defines which type of document is behind url
Line 100  class documentViewer(Folder): Line 100  class documentViewer(Folder):
         '''          '''
                   
         zLOG.LOG("documentViewer (index)", zLOG.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))          zLOG.LOG("documentViewer (index)", zLOG.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
         print "dlbaseurl:", self.digilibBaseUrl  
                   
         if not hasattr(self, 'template'):          if not hasattr(self, 'template'):
             # create template folder if it doesn't exist              # create template folder if it doesn't exist
             print "no template folder -- creating"  
             self.manage_addFolder('template')              self.manage_addFolder('template')
                           
         if not self.digilibBaseUrl:          if not self.digilibBaseUrl:
             self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"              self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
                           
         print "dlbaseurl:", self.digilibBaseUrl  
   
         docinfo = self.getDocinfo(mode=mode, url=url)          docinfo = self.getDocinfo(mode=mode, url=url)
         pageinfo = self.getPageinfo(start=start,current=pn)          pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
         pt = getattr(self.template, 'viewer_main')          pt = getattr(self.template, 'viewer_main')
         return pt(docinfo=docinfo,pageinfo=pageinfo)          return pt(docinfo=docinfo,pageinfo=pageinfo)
       
       
     def imageLink(self,nr):      def getLink(self,param=None,val=None):
         """link hinter den images"""          """link to documentviewer with parameter param set to val"""
         paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING'])          params=self.REQUEST.form.copy()
         params={}          if param is not None:
         for x in paramsTmp.iteritems():              if val is None:
                 params[x[0]]=x[1][0]                  if params.has_key(param):
                           del params[param]
         params['pn']=nr              else:
         newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)                  params[param] = str(val)
         return newUrl                  
           # quote values and assemble into query string
           ps = "&".join(["%s=%s"%(k,urllib.quote(v)) for (k, v) in params.items()])
           url=self.REQUEST['URL1']+"?"+ps
           return url
   
                   
     def getStyle(self, idx, selected, style=""):      def getStyle(self, idx, selected, style=""):
         """returns a string with the given style + 'sel' if path == selected."""          """returns a string with the given style and append 'sel' if path == selected."""
         #zLOG.LOG("documentViewer (getstyle)", zLOG.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))          #zLOG.LOG("documentViewer (getstyle)", zLOG.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
         if idx == selected:          if idx == selected:
             return style + 'sel'              return style + 'sel'
Line 138  class documentViewer(Folder): Line 139  class documentViewer(Folder):
             return style                  return style    
   
                           
     def thumbruler(self,cols,rows,start,maximum):      def isAccessible(self, docinfo):
         """ruler for thumbs"""          """returns if access to the resource is granted"""
         ret=""          access = docinfo.get('accessType', None)
         paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING'])          if access is None:
         params={}              # no information - no access 
         for x in paramsTmp.iteritems():              #TODO: check
               return True
             if not x[0]=="start":          elif access == 'free':
                 params[x[0]]=x[1][0]              return True
           elif access in self.authgroups:
         newUrlSelect=self.REQUEST['URL']+"?"+urllib.urlencode(params)                  # only local access -- only logged in users
         if start>0:              user = getSecurityManager().getUser()
             newStart=max(start-cols*rows,0)              if user is not None:
             params['start']=newStart                  #print "user: ", user
             newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)                  return (user.getUserName() != "Anonymous User")
             ret+="""<a href="%s">prev</a>"""%newUrl              else:
                   return False
   
         ret+="""<select onChange="location.href='%s&start='+this.options[this.selectedIndex].value">"""%newUrlSelect  
         nr,rest=divmod(maximum,cols*rows)  
         if rest > 0:  
             nr+=1  
         for i in range(nr):  
             nr=i*cols*rows  
              
             if (start >= nr) and (start < nr+cols*rows):    
                 ret+="""<option value="%s" selected>%s</option>"""%(nr,nr)  
             else:  
                 ret+="""<option value="%s">%s</option>"""%(nr,nr)  
         ret+="</select>"  
           
         if start<maximum:  
             newStart=min(start+cols*rows,maximum)  
             params['start']=newStart  
             newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)  
             ret+="""<a href="%s">next</a>"""%newUrl  
                   
         return ret          zLOG.LOG("documentViewer (accessOK)", zLOG.INFO, "unknown access type %s"%access)
           return False
       
                   
       def getDirinfoFromDigilib(self,path,docinfo=None):
           """gibt param von dlInfo aus"""
           if docinfo is None:
               docinfo = {}
               
           imageUrl=self.digilibBaseUrl+"/dirInfo-xml.jsp?mo=dir&fn="+path
       
           zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo from %s"%(imageUrl))
           
           for cnt in (1,2,3):
               try:
                   dom = NonvalidatingReader.parseUri(imageUrl)
                   break
               except:
                   zLOG.LOG("documentViewer (getdirinfofromdigilib)", zLOG.ERROR, "error reading %s (try %d)"%(imageUrl,cnt))
           else:
               raise IOError("Unable to get dir-info from %s"%(imageUrl))
           
           sizes=dom.xpath("//dir/size")
           zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo:size"%sizes)
           
           if sizes:
               docinfo['numPages'] = int(getTextFromNode(sizes[0]))
           else:
               docinfo['numPages'] = 0
                           
           return docinfo
       
               
       def getIndexMeta(self, url):
           """returns dom of index.meta document at url"""
           num_retries = 3
           dom = None
           metaUrl = None
           if url.startswith("http://"):
               # real URL
               metaUrl = url
               try:
                   dom = NonvalidatingReader.parseUri(url)
               except:
                   zLOG.LOG("documentViewer (getIndexMata)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])
                   raise IOError("Unable to read index.meta from %s"%(url))
           else:
               # online path
               server=self.digilibBaseUrl+"/servlet/Texter?fn="
               metaUrl=server+url
               if not metaUrl.endswith("index.meta"):
                   metaUrl += "/index.meta"
           
           for n in range(num_retries):
               try:
                   dom = NonvalidatingReader.parseUri(metaUrl)
                   zLOG.LOG("documentViewer (getIndexMata)", zLOG.INFO,metaUrl)
                   break
               except:
                   zLOG.LOG("ERROR documentViewer (getIndexMata)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])
                   
           if dom is None:
               raise IOError("Unable to read index meta from %s"%(url))
                    
           return dom
                           
           
       def getAuthinfoFromIndexMeta(self,path,docinfo=None,dom=None):
           """gets authorization info from the index.meta file at path or given by dom"""
           zLOG.LOG("documentViewer (getauthinfofromindexmeta)", zLOG.INFO,"path: %s"%(path))
           
           access = None
           
           if docinfo is None:
               docinfo = {}
               
           if dom is None:
               dom = self.getIndexMeta(getParentDir(path))
               
           acctype = dom.xpath("//access-conditions/access/@type")
           if acctype and (len(acctype)>0):
               access=acctype[0].value
               if access in ['group', 'institution']:
                   access = getTextFromNode(dom.xpath("//access-conditions/access/name")[0]).lower()
               
           docinfo['accessType'] = access
           return docinfo
                   
                   
     def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None):      def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None):
         """gets bibliographical info from the index.meta file at url or given by dom"""          """gets bibliographical info from the index.meta file at path or given by dom"""
         zLOG.LOG("documentViewer (getbibinfofromindexmeta)", zLOG.INFO,"path: %s"%(path))          zLOG.LOG("documentViewer (getbibinfofromindexmeta)", zLOG.INFO,"path: %s"%(path))
                   
         if docinfo is None:          if docinfo is None:
             docinfo = {}              docinfo = {}
                           
         metaData=self.metadata.main.meta.bib  
         if dom is None:          if dom is None:
             server="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn="              dom = self.getIndexMeta(getParentDir(path))
             path="/".join(path.split("/")[0:-1])  
             metaUrl=server+path+"/index.meta"  
             try:  
                 dom = NonvalidatingReader.parseUri(metaUrl)  
             except:  
                 return docinfo  
                   
         type=dom.xpath("//bib/@type")          metaData=self.metadata.main.meta.bib
         if type and (len(type)>0):          bibtype=dom.xpath("//bib/@type")
             type=type[0].value          if bibtype and (len(bibtype)>0):
         else:              bibtype=bibtype[0].value
             type="generic"          else:
         type=type.replace("-"," ")# wrong typesiin index meta "-" instead of " "              bibtype="generic"
         hash=metaData.generateMappingForType(type)          bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC)
           bibmap=metaData.generateMappingForType(bibtype)
         docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0])          #print "bibmap: ", bibmap, " for: ", bibtype
         docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0])          # if there is no mapping bibmap is empty (mapping sometimes has empty fields)
         docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0])          if len(bibmap) > 0 and len(bibmap['author'][0]) > 0:
               docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['author'][0])[0])
               docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['title'][0])[0])
               docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%bibmap['year'][0])[0])
                   
         return docinfo          return docinfo
   
                   
     def getDocinfoFromTextTool(self,url,docinfo=None):      def getDocinfoFromTextTool(self,url,dom=None,docinfo=None):
        """parse texttool tag in index meta"""         """parse texttool tag in index meta"""
        zLOG.LOG("documentViewer (getdocinfofromtexttool)", zLOG.INFO,"url: %s"%(url))         zLOG.LOG("documentViewer (getdocinfofromtexttool)", zLOG.INFO,"url: %s"%(url))
        if docinfo is None:         if docinfo is None:
            docinfo = {}             docinfo = {}
                         
        try:         if dom is None:
            dom = NonvalidatingReader.parseUri(url)             dom = self.getIndexMeta(url)
        except:  
            zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])  
            return docinfo  
                 
        archivePaths=dom.xpath("//resource/archive-path")         archiveNames=dom.xpath("//resource/name")
          if archiveNames and (len(archiveNames)>0):
              archiveName=getTextFromNode(archiveNames[0])
                 
          archivePaths=dom.xpath("//resource/archive-path")
        if archivePaths and (len(archivePaths)>0):         if archivePaths and (len(archivePaths)>0):
            archivePath=getTextFromNode(archivePaths[0])             archivePath=getTextFromNode(archivePaths[0])
              # clean up archive path
              if archivePath[0] != '/':
                  archivePath = '/' + archivePath
              if not archivePath.endswith(archiveName):
                  archivePath += "/" + archiveName
        else:         else:
            archivePath=None             archivePath=None
                 
        images=dom.xpath("//texttool/image")         imageDirs=dom.xpath("//texttool/image")
                 if imageDirs and (len(imageDirs)>0):
        if images and (len(images)>0):             imageDir=getTextFromNode(imageDirs[0])
            image=getTextFromNode(images[0])  
        else:         else:
            image=None             # we balk with no image tag
              raise IOError("No text-tool info in %s"%(url))
                         
        if image and archivePath:         if imageDir and archivePath:
            image=os.path.join(archivePath,image)             #print "image: ", imageDir, " archivepath: ", archivePath
            image=image.replace("/mpiwg/online",'')             imageDir=os.path.join(archivePath,imageDir)
            pt=getParamFromDigilib(image,'size')             imageDir=imageDir.replace("/mpiwg/online",'')
            docinfo['imagePath'] = image             docinfo=self.getDirinfoFromDigilib(imageDir,docinfo=docinfo)
            docinfo['numberOfPages'] = pt             docinfo['imagePath'] = imageDir
              docinfo['imageURL'] = self.digilibBaseUrl+"/servlet/Scaler?fn="+imageDir
                         
        viewerUrls=dom.xpath("//texttool/digiliburlprefix")         viewerUrls=dom.xpath("//texttool/digiliburlprefix")
          
        if viewerUrls and (len(viewerUrls)>0):         if viewerUrls and (len(viewerUrls)>0):
            viewerUrl=getTextFromNode(viewerUrls[0])             viewerUrl=getTextFromNode(viewerUrls[0])
            docinfo['imageURL'] = viewerURL             docinfo['viewerURL'] = viewerUrl
                                       
        textUrls=dom.xpath("//texttool/text")         textUrls=dom.xpath("//texttool/text")
          
        if textUrls and (len(textUrls)>0):         if textUrls and (len(textUrls)>0):
            textUrl=getTextFromNode(textUrls[0])             textUrl=getTextFromNode(textUrls[0])
            docinfo['textURL'] = textURL             docinfo['textURL'] = textUrl
                                             
        docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom)         docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom)
          docinfo = self.getAuthinfoFromIndexMeta(url,docinfo=docinfo,dom=dom)
        return docinfo         return docinfo
         
   
Line 265  class documentViewer(Folder): Line 333  class documentViewer(Folder):
         zLOG.LOG("documentViewer (getdocinfofromimagepath)", zLOG.INFO,"path: %s"%(path))          zLOG.LOG("documentViewer (getdocinfofromimagepath)", zLOG.INFO,"path: %s"%(path))
         if docinfo is None:          if docinfo is None:
             docinfo = {}              docinfo = {}
         docinfo['imagePath'] = path  
         path=path.replace("/mpiwg/online","")          path=path.replace("/mpiwg/online","")
         pt=getParamFromDigilib(path,'size')          docinfo['imagePath'] = path
         docinfo['numberOfPages'] = pt          docinfo=self.getDirinfoFromDigilib(path,docinfo=docinfo)
         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path          imageUrl=self.digilibBaseUrl+"/servlet/Scaler?fn="+path
         docinfo['imageURL'] = imageUrl          docinfo['imageURL'] = imageUrl
                   
         docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo)          docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo)
           docinfo = self.getAuthinfoFromIndexMeta(path,docinfo=docinfo)
         return docinfo          return docinfo
           
           
Line 294  class documentViewer(Folder): Line 362  class documentViewer(Folder):
             docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)              docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)
         else:          else:
             zLOG.LOG("documentViewer (getdocinfo)", zLOG.ERROR,"unknown mode!")              zLOG.LOG("documentViewer (getdocinfo)", zLOG.ERROR,"unknown mode!")
               raise ValueError("Unknown mode %s"%(mode))
                           
         zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo: %s"%docinfo)          zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo: %s"%docinfo)
         self.REQUEST.SESSION['docinfo'] = docinfo          self.REQUEST.SESSION['docinfo'] = docinfo
         return docinfo          return docinfo
                   
                   
     def getPageinfo(self, start, current):      def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None):
         """returns pageinfo with the given parameters"""          """returns pageinfo with the given parameters"""
         pageinfo = {}          pageinfo = {}
         pageinfo['start'] = start          current = getInt(current)
         pageinfo['current'] = current          pageinfo['current'] = current
           rows = int(rows or self.thumbrows)
           pageinfo['rows'] = rows
           cols = int(cols or self.thumbcols)
           pageinfo['cols'] = cols
           grpsize = cols * rows
           pageinfo['groupsize'] = grpsize
           start = getInt(start, default=(int(current / grpsize) * grpsize +1))
           pageinfo['start'] = start
           pageinfo['end'] = start + grpsize
           if docinfo is not None:
               np = int(docinfo['numPages'])
               pageinfo['end'] = min(pageinfo['end'], np)
               pageinfo['numgroups'] = int(np / grpsize)
               if np % grpsize > 0:
                   pageinfo['numgroups'] += 1
                   
         return pageinfo          return pageinfo
                                   
     def text(self,mode,url,pn):      def text(self,mode,url,pn):
Line 311  class documentViewer(Folder): Line 397  class documentViewer(Folder):
         if mode=="texttool": #index.meta with texttool information          if mode=="texttool": #index.meta with texttool information
             (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)              (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)
                   
         print textpath          #print textpath
         try:          try:
             dom = NonvalidatingReader.parseUri(textpath)              dom = NonvalidatingReader.parseUri(textpath)
         except:          except:
Line 360  class documentViewer(Folder): Line 446  class documentViewer(Folder):
 #        return list  #        return list
 #  #
   
     def image(self,mode,url,pn):  
         """give image out"""  
         if mode=="texttool": #index.meta with texttool information  
             (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)  
             if not viewerUrl:  
                 viewerUrl=self.imageViewerUrl  
             url=viewerUrl+"pn=%s&fn=%s"%(pn,imagepath[0])  
             ret="""<iframe height="100%%" width="100%%" src="%s"/>"""%url  
             return url  
         elif mode=="imagepath":  
             url=url.replace("/mpiwg/online","")  
             url=self.imageViewerUrl+"pn=%s&fn=%s"%(pn,url)  
             ret="""<iframe height="100%%" width="100%%" src="%s"/>"""%url  
             return url  
               
           
     def findDigilibUrl(self):      def findDigilibUrl(self):
         """try to get the digilib URL from zogilib"""          """try to get the digilib URL from zogilib"""
         url = self.imageViewerUrl[:-1] + "/getScalerUrl"          url = self.imageViewerUrl[:-1] + "/getScalerUrl"
Line 385  class documentViewer(Folder): Line 455  class documentViewer(Folder):
         except:          except:
             return None              return None
           
     def changeDocumentViewer(self,imageViewerUrl,title="",digilibBaseUrl=None,RESPONSE=None):      def changeDocumentViewer(self,imageViewerUrl,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=10,authgroups='mpiwg',RESPONSE=None):
         """init document viewer"""          """init document viewer"""
         self.title=title          self.title=title
         self.imageViewerUrl=imageViewerUrl          self.imageViewerUrl=imageViewerUrl
         self.digilibBaseUrl = digilibBaseUrl          self.digilibBaseUrl = digilibBaseUrl
                   self.thumbrows = thumbrows
           self.thumbcols = thumbcols
           self.authgroups = [s.strip().lower() for s in authgroups.split(',')]
         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.10.2.1

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