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

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

version 1.2, 2005/12/23 14:01:29 version 1.3, 2006/04/06 17:13:43
Line 16  import Ft.Xml.XPath Line 16  import Ft.Xml.XPath
 import os.path  import os.path
 import cgi  import cgi
 import urllib  import urllib
   import zLOG
   
 def getTextFromNode(nodename):  def getTextFromNode(nodename):
     nodelist=nodename.childNodes      nodelist=nodename.childNodes
Line 36  def urlopen(url): Line 37  def urlopen(url):
           
 def getParamFromDigilib(path,param):  def getParamFromDigilib(path,param):
     """gibt param von dlInfo aus"""      """gibt param von dlInfo aus"""
     imageUrl=genericDigilib+"/dlInfo-xml.jsp?fn="+path      imageUrl=genericDigilib+"/dirInfo-xml.jsp?mo=dir&fn="+path
   
       zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo (%s) from %s"%(param,imageUrl))
   
     try:      try:
         dom = NonvalidatingReader.parseUri(imageUrl)          dom = NonvalidatingReader.parseUri(imageUrl)
     except:      except:
         return None          return None
           
           params=dom.xpath("//dir/%s"%param)
     params=dom.xpath("//document-parameters/parameter[@name='%s']/@value"%param)      zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo:%s"%params)
           
     if params:      if params:
         return params[0].value          return getTextFromNode(params[0])
           
 def parseUrlTextTool(url):  
    """parse index meta"""  
           
    try:  
        dom = NonvalidatingReader.parseUri(url)  
    except:  
        zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])  
        return (None,None,None)  
         
    archivePaths=dom.xpath("//resource/archive-path")  
         
    if archivePaths and (len(archivePaths)>0):  ##
        archivePath=getTextFromNode(archivePaths[0])  ## documentViewer class
    else:  ##
        archivePath=None  class documentViewer(Folder):
      
       
    images=dom.xpath("//texttool/image")  
      
    if images and (len(images)>0):  
        image=getTextFromNode(images[0])  
    else:  
        image=None  
          
    if image and archivePath:  
        image=os.path.join(archivePath,image)  
        image=image.replace("/mpiwg/online",'')  
        pt=getParamFromDigilib(image,'pt')  
   
    else:  
        image=None  
          
    viewerUrls=dom.xpath("//texttool/digiliburlprefix")  
      
    if viewerUrls and (len(viewerUrls)>0):  
        viewerUrl=getTextFromNode(viewerUrls[0])  
    else:  
        viewerUrl=None  
      
      
    textUrls=dom.xpath("//texttool/text")  
      
    if textUrls and (len(textUrls)>0):  
        textUrl=getTextFromNode(textUrls[0])  
    else:  
        textUrl=None  
    return viewerUrl,(image,pt),textUrl  
   
   
 class documentViewer(ZopePageTemplate):  
     """document viewer"""      """document viewer"""
   
     meta_type="Document viewer"      meta_type="Document viewer"
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     manage_options=ZopePageTemplate.manage_options+(      manage_options=Folder.manage_options+(
         {'label':'main config','action':'changeDocumentViewerForm'},          {'label':'main config','action':'changeDocumentViewerForm'},
         )          )
   
     _default_content_fn = os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt')      # templates and forms
       viewer_main = PageTemplateFile('zpt/viewer_main', globals())
       thumbs_main = PageTemplateFile('zpt/thumbs_main', globals())
       image_main = PageTemplateFile('zpt/image_main', globals())
       head_main = PageTemplateFile('zpt/head_main', globals())
       docuviewer_css = PageTemplateFile('css/docuviewer.css', globals())
           
     def __init__(self,id,imageViewerUrl,title=""):      security.declareProtected('View management screens','changeDocumentViewerForm')    
       changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
   
       
       def __init__(self,id,imageViewerUrl,title="",digilibBaseUrl=None):
         """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 self.digilibBaseUrl:
               self.digilibBaseUrl = self.findDigilibUrl()
           # add template folder so we can always use template.something
           self.manage_addFolder('template')
                   
     security.declareProtected('View management screens','changeDocumentViewerForm')      
     def changeDocumentViewerForm(self):  
         """change it"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeDocumentViewer.zpt')).__of__(self)  
         return pt()  
       
       security.declareProtected('View','index_html')
       def index_html(self,mode,url,start=0,pn=1):
           '''
           view it
           @param mode: defines which type of document is behind url
           @param url: url which contains display information
           '''
       
     def changeDocumentViewer(self,imageViewerUrl,title="",RESPONSE=None):          zLOG.LOG("documentViewer (index)", zLOG.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
         """init document viewer"""          print "dlbaseurl:", self.digilibBaseUrl
         self.title=title  
         self.imageViewerUrl=imageViewerUrl  
                   
         if RESPONSE is not None:          if not hasattr(self, 'template'):
             RESPONSE.redirect('manage_main')              # create template folder if it doesn't exist
               print "no template folder -- creating"
               self.manage_addFolder('template')
               
           if not self.digilibBaseUrl:
               self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
               
           print "dlbaseurl:", self.digilibBaseUrl
   
           docinfo = self.getDocinfo(mode=mode, url=url)
           pageinfo = self.getPageinfo(start=start,current=pn)
           pt = getattr(self.template, 'viewer_main')
           return pt(docinfo=docinfo,pageinfo=pageinfo)
           
           
     def imageLink(self,nr):      def imageLink(self,nr):
Line 143  class documentViewer(ZopePageTemplate): Line 129  class documentViewer(ZopePageTemplate):
         newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)          newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)
         return newUrl          return newUrl
                   
       def getStyle(self, idx, selected, style=""):
           """returns a string with the given style + 'sel' if path == selected."""
           #zLOG.LOG("documentViewer (getstyle)", zLOG.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style))
           if idx == selected:
               return style + 'sel'
           else:
               return style    
   
                   
     def thumbruler(self,cols,rows,start,maximum):      def thumbruler(self,cols,rows,start,maximum):
         """ruler for thumbs"""          """ruler for thumbs"""
Line 162  class documentViewer(ZopePageTemplate): Line 156  class documentViewer(ZopePageTemplate):
             ret+="""<a href="%s">prev</a>"""%newUrl              ret+="""<a href="%s">prev</a>"""%newUrl
   
   
         ret+="""<select onChange="location.href='%s&start='+this.options[this.selectedIndex].value" """%newUrlSelect          ret+="""<select onChange="location.href='%s&start='+this.options[this.selectedIndex].value">"""%newUrlSelect
         nr,rest=divmod(maximum,cols*rows)          nr,rest=divmod(maximum,cols*rows)
         if rest > 0:          if rest > 0:
             nr+=1              nr+=1
Line 183  class documentViewer(ZopePageTemplate): Line 177  class documentViewer(ZopePageTemplate):
                   
         return ret          return ret
                   
     def textToolThumb(self,url,start=0):  
         """understands the texttool format  
         @param url: url to index.meta with texttool tag  
         """  
         (viewerUrl,imagepath,textpath)=parseUrlTextTool(url)  
           
         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%imagepath[0]  
           
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)  
         return pt(imageUrl=imageUrl,pt=imagepath[1],start=start)  
       
     def imagePathThumb(self,path,start=0):  
         """path ist the path to the images it is assumes that the index.meta file is one level higher."""  
                   
         path=path.replace("/mpiwg/online","")  
         pt=getParamFromDigilib(path,'pt')  
         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path  
                   
         pageT=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)      def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None):
         return pageT(imageUrl=imageUrl,pt=pt,start=start)          """gets bibliographical info from the index.meta file at url or given by dom"""
           zLOG.LOG("documentViewer (getbibinfofromindexmeta)", zLOG.INFO,"path: %s"%(path))
           
     def headerFromIndexMeta(self,path):          if docinfo is None:
         """gibt header from index meta out"""              docinfo = {}
                   
         metaData=self.metadata.main.meta.bib          metaData=self.metadata.main.meta.bib
         server="http://foxridge.mpiwg-berlin.mpg.de"          if dom is None:
               server="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn="
         path="/".join(path.split("/")[0:-1])          path="/".join(path.split("/")[0:-1])
         metaUrl=server+path+"/index.meta"          metaUrl=server+path+"/index.meta"
                       try:
         dom = NonvalidatingReader.parseUri(metaUrl)          dom = NonvalidatingReader.parseUri(metaUrl)
               except:
                   return docinfo
           
         type=dom.xpath("//bib/@type")          type=dom.xpath("//bib/@type")
         if type and (len(type)>0):          if type and (len(type)>0):
             type=type[0].value              type=type[0].value
Line 221  class documentViewer(ZopePageTemplate): Line 204  class documentViewer(ZopePageTemplate):
         type=type.replace("-"," ")# wrong typesiin index meta "-" instead of " "          type=type.replace("-"," ")# wrong typesiin index meta "-" instead of " "
         hash=metaData.generateMappingForType(type)          hash=metaData.generateMappingForType(type)
           
         author=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0])          docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0])
         title=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0])          docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0])
         year=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0])          docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0])
           
           return docinfo
   
           
       def getDocinfoFromTextTool(self,url,docinfo=None):
          """parse texttool tag in index meta"""
          zLOG.LOG("documentViewer (getdocinfofromtexttool)", zLOG.INFO,"url: %s"%(url))
          if docinfo is None:
              docinfo = {}
              
          try:
              dom = NonvalidatingReader.parseUri(url)
          except:
              zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])
              return docinfo
          
          archivePaths=dom.xpath("//resource/archive-path")
          
          if archivePaths and (len(archivePaths)>0):
              archivePath=getTextFromNode(archivePaths[0])
          else:
              archivePath=None
          
          images=dom.xpath("//texttool/image")
          
          if images and (len(images)>0):
              image=getTextFromNode(images[0])
          else:
              image=None
              
          if image and archivePath:
              image=os.path.join(archivePath,image)
              image=image.replace("/mpiwg/online",'')
              pt=getParamFromDigilib(image,'size')
              docinfo['imagePath'] = image
              docinfo['numberOfPages'] = pt
              
          viewerUrls=dom.xpath("//texttool/digiliburlprefix")
          
          if viewerUrls and (len(viewerUrls)>0):
              viewerUrl=getTextFromNode(viewerUrls[0])
              docinfo['imageURL'] = viewerURL
                     
          textUrls=dom.xpath("//texttool/text")
          
          if textUrls and (len(textUrls)>0):
              textUrl=getTextFromNode(textUrls[0])
              docinfo['textURL'] = textURL
                        
          docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom)
          return docinfo
      
   
       def getDocinfoFromImagePath(self,path,docinfo=None):
           """path ist the path to the images it assumes that the index.meta file is one level higher."""
           zLOG.LOG("documentViewer (getdocinfofromimagepath)", zLOG.INFO,"path: %s"%(path))
           if docinfo is None:
               docinfo = {}
           docinfo['imagePath'] = path
           path=path.replace("/mpiwg/online","")
           pt=getParamFromDigilib(path,'size')
           docinfo['numberOfPages'] = pt
           imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path
           docinfo['imageURL'] = imageUrl
                   
         return author,title,year          docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo)
           return docinfo
       
       
       def getDocinfo(self, mode, url):
           """returns docinfo depending on mode"""
           zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"mode: %s, url: %s"%(mode,url))
           # look for cached docinfo in session
           if self.REQUEST.SESSION.has_key('docinfo'):
               docinfo = self.REQUEST.SESSION['docinfo']
               # check if its still current
               if docinfo is not None and docinfo.get('mode') == mode and docinfo.get('url') == url:
                   zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo in session: %s"%docinfo)
                   return docinfo
           # new docinfo
           docinfo = {'mode': mode, 'url': url}
           if mode=="texttool": #index.meta with texttool information
               docinfo = self.getDocinfoFromTextTool(url, docinfo=docinfo)
           elif mode=="imagepath":
               docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo)
           else:
               zLOG.LOG("documentViewer (getdocinfo)", zLOG.ERROR,"unknown mode!")
           zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo: %s"%docinfo)
           self.REQUEST.SESSION['docinfo'] = docinfo
           return docinfo
           
           
       def getPageinfo(self, start, current):
           """returns pageinfo with the given parameters"""
           pageinfo = {}
           pageinfo['start'] = start
           pageinfo['current'] = current
           return pageinfo
                   
     def text(self,mode,url,pn):      def text(self,mode,url,pn):
         """give text"""          """give text"""
Line 280  class documentViewer(ZopePageTemplate): Line 359  class documentViewer(ZopePageTemplate):
 #  #
 #        return list  #        return list
 #      #    
   
     def image(self,mode,url,pn):      def image(self,mode,url,pn):
         """give image out"""          """give image out"""
         if mode=="texttool": #index.meta with texttool information          if mode=="texttool": #index.meta with texttool information
Line 296  class documentViewer(ZopePageTemplate): Line 376  class documentViewer(ZopePageTemplate):
             return url              return url
                           
                   
     def thumbs(self,mode,url,start):      def findDigilibUrl(self):
         """give thumbs out"""          """try to get the digilib URL from zogilib"""
         if mode=="texttool": #index.meta with texttool information          url = self.imageViewerUrl[:-1] + "/getScalerUrl"
             return self.textToolThumb(url,int(start))          try:
         elif mode=="imagepath":              scaler = urlopen(url).read()
             return self.imagePathThumb(url,int(start))              return scaler.replace("/servlet/Scaler?", "")
                   except:
     security.declareProtected('View','index_html')              return None
       
           
     def index_html(self,mode,url,start=0,pn=1):      def changeDocumentViewer(self,imageViewerUrl,title="",digilibBaseUrl=None,RESPONSE=None):
         '''          """init document viewer"""
         view it          self.title=title
         @param mode: defines which type of document is behind url          self.imageViewerUrl=imageViewerUrl
         @param url: url which contains display information          self.digilibBaseUrl = digilibBaseUrl
         '''  
                   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
           
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt')).__of__(self)  
         return pt(mode=mode,url=url,start=start,pn=pn)  
                   
                   
                   
Line 323  class documentViewer(ZopePageTemplate): Line 401  class documentViewer(ZopePageTemplate):
   
 def manage_AddDocumentViewerForm(self):  def manage_AddDocumentViewerForm(self):
     """add the viewer form"""      """add the viewer form"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addDocumentViewer.zpt')).__of__(self)      pt=PageTemplateFile('zpt/addDocumentViewer', globals()).__of__(self)
     return pt()      return pt()
       
 def manage_AddDocumentViewer(self,id,imageViewerUrl="",title="",RESPONSE=None):  def manage_AddDocumentViewer(self,id,imageViewerUrl="",title="",RESPONSE=None):
Line 334  def manage_AddDocumentViewer(self,id,ima Line 412  def manage_AddDocumentViewer(self,id,ima
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
   
   ##
   ## DocumentViewerTemplate class
   ##
   class DocumentViewerTemplate(ZopePageTemplate):
       """Template for document viewer"""
       meta_type="DocumentViewer Template"
   
   
   def manage_addDocumentViewerTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile('zpt/addDocumentViewerTemplate', globals()).__of__(self)
       return pt()
   
   def manage_addDocumentViewerTemplate(self, id='viewer_main', title=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
   
       self._setObject(id, DocumentViewerTemplate(id))
       ob = getattr(self, id)
       ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/viewer_main.zpt')).read(),None)
       if title:
           ob.pt_setTitle(title)
       try:
           u = self.DestinationURL()
       except AttributeError:
           u = REQUEST['URL1']
           
       u = "%s/%s" % (u, urllib.quote(id))
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
   
       
   
Removed from v.1.2  
changed lines
  Added in v.1.3

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