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

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

version 1.2, 2005/12/23 14:01:29 version 1.5, 2006/04/10 10:13:01
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 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):
     nodelist=nodename.childNodes      nodelist=nodename.childNodes
Line 36  def urlopen(url): Line 45  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])
   
       
   
   
   ##
   ## documentViewer class
   ##
   class documentViewer(Folder):
       """document viewer"""
   
       meta_type="Document viewer"
       
       security=ClassSecurityInfo()
       manage_options=Folder.manage_options+(
           {'label':'main config','action':'changeDocumentViewerForm'},
           )
   
       # 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())
   
       security.declareProtected('View management screens','changeDocumentViewerForm')    
       changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals())
   
       
       def __init__(self,id,imageViewerUrl,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=10):
           """init document viewer"""
           self.id=id
           self.title=title
           self.imageViewerUrl=imageViewerUrl
           if not digilibBaseUrl:
               self.digilibBaseUrl = self.findDigilibUrl()
           else:
               self.digilibBaseUrl = digilibBaseUrl
           self.thumbcols = thumbcols
           self.thumbrows = thumbrows
           # add template folder so we can always use template.something
           self.manage_addFolder('template')
   
   
       security.declareProtected('View','index_html')
       def index_html(self,mode,url,start=None,pn=1):
           '''
           view it
           @param mode: defines which type of document is behind url
           @param url: url which contains display information
           '''
           
 def parseUrlTextTool(url):          zLOG.LOG("documentViewer (index)", zLOG.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn))
    """parse index meta"""          print "dlbaseurl:", self.digilibBaseUrl
           
           if not hasattr(self, 'template'):
               # 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"
               
           docinfo = self.getDocinfo(mode=mode,url=url)
           pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo)
           pt = getattr(self.template, 'viewer_main')
           return pt(docinfo=docinfo,pageinfo=pageinfo)
     
     
       def getLink(self,param=None,val=None):
           """link to documentviewer with parameter param set to val"""
           params=cgi.parse_qs(self.REQUEST['QUERY_STRING'])
           if param is not None:
               if val is None and params.has_key(param):
                   del params[param]
               else:
                   params[param] = val
           
           url=self.REQUEST['URL']+"?"+urllib.urlencode(params, doseq=True)
           return url
   
       
       def getStyle(self, idx, selected, style=""):
           """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))
           if idx == selected:
               return style + 'sel'
           else:
               return style    
           
           
       def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None):
           """gets bibliographical info from the index.meta file at url or given by dom"""
           zLOG.LOG("documentViewer (getbibinfofromindexmeta)", zLOG.INFO,"path: %s"%(path))
           
           if docinfo is None:
               docinfo = {}
               
           if dom is None:
               server="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn="
               path="/".join(path.split("/")[0:-1])
               metaUrl=server+path+"/index.meta"
               try:
                   dom = NonvalidatingReader.parseUri(metaUrl)
               except:
                   return docinfo
           
           metaData=self.metadata.main.meta.bib
           bibtype=dom.xpath("//bib/@type")
           if bibtype and (len(bibtype)>0):
               bibtype=bibtype[0].value
           else:
               bibtype="generic"
           bibtype=bibtype.replace("-"," ") # wrong typesiin index meta "-" instead of " " (not wrong! ROC)
           bibmap=metaData.generateMappingForType(bibtype)
           if len(bibmap) > 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
   
           
       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:     try:
        dom = NonvalidatingReader.parseUri(url)         dom = NonvalidatingReader.parseUri(url)
    except:     except:
        zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])         zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])
        return (None,None,None)             return docinfo
         
    archivePaths=dom.xpath("//resource/archive-path")     archivePaths=dom.xpath("//resource/archive-path")
         
Line 65  def parseUrlTextTool(url): Line 200  def parseUrlTextTool(url):
    else:     else:
        archivePath=None         archivePath=None
         
       
    images=dom.xpath("//texttool/image")     images=dom.xpath("//texttool/image")
         
    if images and (len(images)>0):     if images and (len(images)>0):
Line 76  def parseUrlTextTool(url): Line 210  def parseUrlTextTool(url):
    if image and archivePath:     if image and archivePath:
        image=os.path.join(archivePath,image)         image=os.path.join(archivePath,image)
        image=image.replace("/mpiwg/online",'')         image=image.replace("/mpiwg/online",'')
        pt=getParamFromDigilib(image,'pt')             pt=getParamFromDigilib(image,'size')
              docinfo['imagePath'] = image
    else:             docinfo['numPages'] = pt
        image=None  
                 
    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])
    else:             docinfo['imageURL'] = viewerURL
        viewerUrl=None  
      
         
    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])
    else:             docinfo['textURL'] = textURL
        textUrl=None  
    return viewerUrl,(image,pt),textUrl  
   
          docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom)
          return docinfo
   
 class documentViewer(ZopePageTemplate):  
     """document viewer"""  
   
     meta_type="Document viewer"  
       
     security=ClassSecurityInfo()  
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'main config','action':'changeDocumentViewerForm'},  
         )  
   
     _default_content_fn = os.path.join(package_home(globals()),'zpt','documentViewer_template.zpt')  
       
     def __init__(self,id,imageViewerUrl,title=""):  
         """init document viewer"""  
         self.id=id  
         self.title=title  
         self.imageViewerUrl=imageViewerUrl  
           
     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()  
     
     
     def changeDocumentViewer(self,imageViewerUrl,title="",RESPONSE=None):  
         """init document viewer"""  
         self.title=title  
         self.imageViewerUrl=imageViewerUrl  
           
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
       
       
     def imageLink(self,nr):  
         """link hinter den images"""  
         paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING'])  
         params={}  
         for x in paramsTmp.iteritems():  
                 params[x[0]]=x[1][0]  
       
         params['pn']=nr  
         newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)  
         return newUrl  
           
           
     def thumbruler(self,cols,rows,start,maximum):  
         """ruler for thumbs"""  
         ret=""  
         paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING'])  
         params={}  
         for x in paramsTmp.iteritems():  
   
             if not x[0]=="start":  
                 params[x[0]]=x[1][0]  
   
         newUrlSelect=self.REQUEST['URL']+"?"+urllib.urlencode(params)      
         if start>0:  
             newStart=max(start-cols*rows,0)  
             params['start']=newStart  
             newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params)  
             ret+="""<a href="%s">prev</a>"""%newUrl  
   
   
         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  
           
     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."""  
                   
       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","")          path=path.replace("/mpiwg/online","")
         pt=getParamFromDigilib(path,'pt')          pt=getParamFromDigilib(path,'size')
           docinfo['numPages'] = pt
         imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path          imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path
           docinfo['imageURL'] = imageUrl
                   
         pageT=PageTemplateFile(os.path.join(package_home(globals()),'zpt','thumbs.zpt')).__of__(self)          docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo)
         return pageT(imageUrl=imageUrl,pt=pt,start=start)          return docinfo
           
     def headerFromIndexMeta(self,path):  
         """gibt header from index meta out"""  
           
         metaData=self.metadata.main.meta.bib  
         server="http://foxridge.mpiwg-berlin.mpg.de"  
         path="/".join(path.split("/")[0:-1])  
         metaUrl=server+path+"/index.meta"  
                   
         dom = NonvalidatingReader.parseUri(metaUrl)      def getDocinfo(self, mode, url):
         type=dom.xpath("//bib/@type")          """returns docinfo depending on mode"""
         if type and (len(type)>0):          zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"mode: %s, url: %s"%(mode,url))
             type=type[0].value          # 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:          else:
             type="generic"              zLOG.LOG("documentViewer (getdocinfo)", zLOG.ERROR,"unknown mode!")
         type=type.replace("-"," ")# wrong typesiin index meta "-" instead of " "          zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo: %s"%docinfo)
         hash=metaData.generateMappingForType(type)          self.REQUEST.SESSION['docinfo'] = docinfo
               return docinfo
         author=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0])          
         title=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0])          
         year=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0])      def getPageinfo(self, current, start=None, rows=None, cols=None, docinfo=None):
           """returns pageinfo with the given parameters"""
           pageinfo = {}
           current = getInt(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))
           print "start3:", start
           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 author,title,year          return pageinfo
                   
     def text(self,mode,url,pn):      def text(self,mode,url,pn):
         """give text"""          """give text"""
Line 280  class documentViewer(ZopePageTemplate): Line 346  class documentViewer(ZopePageTemplate):
 #  #
 #        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 thumbs(self,mode,url,start):  
         """give thumbs out"""  
         if mode=="texttool": #index.meta with texttool information  
             return self.textToolThumb(url,int(start))  
         elif mode=="imagepath":  
             return self.imagePathThumb(url,int(start))  
           
     security.declareProtected('View','index_html')  
           
       def findDigilibUrl(self):
           """try to get the digilib URL from zogilib"""
           url = self.imageViewerUrl[:-1] + "/getScalerUrl"
           try:
               scaler = urlopen(url).read()
               return scaler.replace("/servlet/Scaler?", "")
           except:
               return None
           
     def index_html(self,mode,url,start=0,pn=1):      def changeDocumentViewer(self,imageViewerUrl,title="",digilibBaseUrl=None,thumbrows=2,thumbcols=10,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
         '''          self.thumbrows = thumbrows
           self.thumbcols = thumbcols
                   
           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 374  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 385  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.5

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