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

Diff for /zogiLib/zogiLib.py between versions 1.3 and 1.73

version 1.3, 2004/03/26 14:19:50 version 1.73, 2011/02/14 16:33:43
Line 1 Line 1
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from AccessControl import ClassSecurityInfo
   from Globals import package_home
   from OFS.Folder import Folder
   from OFS.Image import Image
   from OFS.Image import File
   from OFS.SimpleItem import SimpleItem
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   from types import *
   from Globals import package_home, ImageFile
 import xml.dom.minidom  from xml_helpers import getUniqueElementText,getText
 from OFS.Folder import Folder  import cgi
 from xml_helpers import getText  
 import os  import os
   import random
 import re  import re
 import string  import string
 import urllib  import urllib
 from Globals import package_home  import xml.dom.minidom
   
 def getString(self,key,default=''):  ZOGIVERSION = "0.10.4b ROC 13.11.2006"
     try:  
         return self.REQUEST[key]  
     except:  
         return default  
   
   def cropf(f):
       """returns a float with reduced precision"""
       return float(int(f * 10000)/10000.0)
   
   
   def browserCheck(self):
       """check the browsers request to find out the browser type"""
       bt = {}
       ua = self.REQUEST.get_header("HTTP_USER_AGENT")
       bt['ua'] = ua
       bt['isIE'] = False
       bt['isN4'] = False
       if string.find(ua, 'MSIE') > -1:
           bt['isIE'] = True
       else:
           bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
           
 class zogiLib_navTemplate(ZopePageTemplate):      try:
     """pageTemplate Objekt"""          nav = ua[string.find(ua, '('):]
     meta_type="zogiLib_navTemplate"          ie = string.split(nav, "; ")[1]
           if string.find(ie, "MSIE") > -1:
               bt['versIE'] = string.split(ie, " ")[1]
       except: pass
   
     _default_content_fn = os.path.join(package_home(globals()),      bt['isMac'] = string.find(ua, 'Macintosh') > -1
                                        'zpt/zogiLib_NavTemplateDefault.zpt')      bt['isWin'] = string.find(ua, 'Windows') > -1
       bt['isIEWin'] = bt['isIE'] and bt['isWin']
       bt['isIEMac'] = bt['isIE'] and bt['isMac']
       bt['staticHTML'] = False
   
     manage_options=ZopePageTemplate.manage_options+(      return bt
         {'label':'Copy to Filesystem','action':'copyContent'},  
        )  
   
     def getPath(self):  
         """get path"""  
         return getPath(self,'thumbtemplate.templ')  
           
     ## def changeECHO_pageTemplateWeightForm(self):  class zogiImage(SimpleItem):
 ##         """change"""      """einzelnes Image"""
 ##         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self)      meta_type="zogiImage"
 ##         return pt()  
   
 ##     def changeECHO_pageTemplateWeight(self,weight,content_type,RESPONSE=None):      manage_options=(
 ##         """change"""          {'label':'Main config','action':'changeZogiImageForm'},
 ##         self.weight=weight         )+SimpleItem.manage_options
 ##         self.content_type=content_type  
   
 ##         if RESPONSE is not None:  
 ##             RESPONSE.redirect('manage_main')  
                   
       def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
           """init"""
           self.id=id
           self.title=title
           if baseUrl:
               self.baseUrl=baseUrl
           else:
               self.baseUrl="http://digilib.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?"
   
     def copyContent(self):          self.queryString=queryString
         """copycontent to path"""          self.content_type=content_type
           self.precondition=precondition
   
       #def getData(self):
       #    """getUrlData"""
       #    return urllib.urlopen(self.baseUrl+self.queryString)
   
       changeZogiImageForm = PageTemplateFile('zpt/changeZogiImageForm.zpt', globals())
       
       def index_html(self, REQUEST, RESPONSE):
           """service the request by redirecting to digilib server"""
           # use status 307 = moved temporarily
           RESPONSE.redirect(self.baseUrl+self.queryString, status=307)
           return ''
   
         return "copied to:"+copyContent(self,'thumbtemplate.templ')  
                   
       def rescale(self,width=None,height=None):
           """andere parameter im querystring"""
           qs=cgi.parse_qs(self.queryString)
           for x in qs.keys():
               if type(qs[x]) is ListType:
                   qs[x]=qs[x][0]
           
           if width:
               qs['dw']=width
           if height:
               qs['dh']=height
           
           qsneu=urllib.urlencode(qs)
           self.queryString=qsneu
           return "done"
       
       
       def setWithDigilibURL(self,digilibUrl):
           """take all parameters from digilib URL string"""
           base = re.match('(.*?/Scaler\?)(.*)', digilibUrl)
           if base is not None:
               params = base.group(2).split('&')
               newparams = []
               # filter out the parameters we want
               for p in params:
                   (key, val) = p.split('=')
                   if key in ['fn','pn','dw','dh','ww','wh','wx','wy','mo']:
                       newparams.append(p)
               # set the new parameters
               if len(newparams) > 1:
                   self.baseUrl = base.group(1)
                   self.queryString = '&'.join(newparams)
                   return True
           
 def manage_addZogiLib_NavTemplateForm(self):          return False
     """Form for adding"""  
     pt=PageTemplateFile('Products/zogiLib/zpt/AddZogilib_NavTemplate.zpt').__of__(self)  
     return pt()  
   
   
       def changeZogiImage(self,title,baseUrl, queryString, digilibUrl=None, RESPONSE=None):
           """change it"""
           self.title=title
           self.baseUrl=baseUrl
           self.queryString=queryString
           if digilibUrl is not None and len(digilibUrl) > 0:
               self.setWithDigilibURL(digilibUrl)
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
 def manage_addZogiLib_NavTemplate(self, id,title=None, text=None,  
                            REQUEST=None, submit=None):  
     "Add a Page Template with optional file content."  
   
   def manage_addZogiImageForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
       return pt()
           
     id = str(id)  
     if REQUEST is None:  
         self._setObject(id, zogilib_NavTemplate(id, text))  
         ob = getattr(self, id)  
                 
         if title:  def manage_addZogiImage(self,id,title,baseUrl,queryString,digilibUrl=None,RESPONSE=None):
             ob.pt_setTitle(title)      """add zogiimage"""
         return ob      newObj=zogiImage(id,title,baseUrl, queryString)
     else:      self.Destination()._setObject(id,newObj)
         file = REQUEST.form.get('file')      if digilibUrl is not None and len(digilibUrl) > 0:
         headers = getattr(file, 'headers', None)          newObj.setWithDigilibURL(digilibUrl)
         if headers is None or not file.filename:      if RESPONSE is not None:
             zpt = zogilib_NavTemplate(id)          RESPONSE.redirect('manage_main')
         else:  
             zpt = zogilib_NavTemplate(id, file, headers.get('content_type'))  
   
         self._setObject(id, zpt)  
         ob = getattr(self, id)  
   
   
         try:  class zogiLib(Folder):
             u = self.DestinationURL()      """digilib frontend with ZOPE"""
         except AttributeError:  
             u = REQUEST['URL1']  
   
         if submit == " Add and Edit ":  
             u = "%s/%s" % (u, quote(id))  
         REQUEST.RESPONSE.redirect(u+'/manage_main')  
     return ''  
   
       meta_type="zogiLib"
       #xxxx
       security=ClassSecurityInfo()
   
       manage_options = Folder.manage_options+(
               {'label':'Main Config','action':'changeZogiLibForm'},
               )
                   
 def readNavTemp(fileName):      def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
     """navtemp"""          """init"""
           
           self.id = id
           self.title = title
           self.dlServerURL = dlServerURL
           self.basePath = basePath
           self.layout = layout
           self.dlTarget = dlTarget
           
     if os.path.exists(fileName+"/index.meta"):          if dlToolbarBaseURL:
         dom=xml.dom.minidom.parse(fileName+"/index.meta")              self.dlToolbarBaseURL = dlToolbarBaseURL
     else:      else:
         return None              self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
       
       
     try:  
         navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)  
     except:  
         navTag=None  
     return navTag  
       
           
 class zogiLib(Folder):  
     """StandardElement"""  
   
     meta_type="zogiLib"  
   
     def getDlInfo(self):          self.manage_addFolder('template')
         """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):      # form templates
         """pagenums"""      main_book      = PageTemplateFile('zpt/main_book', globals())
         return self.getDlInfo()['pt']      main_image     = PageTemplateFile('zpt/main_image', globals())
       main_metaData  = PageTemplateFile('zpt/main_metadata', globals())
       main_embed      = PageTemplateFile('zpt/main_embed', globals())
       #main_static    = PageTemplateFile('zpt/main_static', globals())
       options        = PageTemplateFile('zpt/options', globals())
       #changeForm     = PageTemplateFile('zpt/changeForm', globals())
   
       # display templates
       aux_divs       = PageTemplateFile('zpt/aux_divs', globals())
       #aux_divsN4     = PageTemplateFile('zpt/aux_divsN4', globals())
       img_div        = PageTemplateFile('zpt/img_div', globals())
       
       # javascripts
       head_js        = PageTemplateFile('zpt/head_js', globals())
       jslib_js       = PageTemplateFile('js/baselib.js', globals())
       dllib_js       = PageTemplateFile('js/dllib.js', globals())
       
       # graphic files
       arr_right = ImageFile('images/right.gif', globals())
       arr_left  = ImageFile('images/left.gif', globals())
       arr_up    = ImageFile('images/up.gif', globals())
       arr_down  = ImageFile('images/down.gif', globals())
       mark1     = ImageFile('images/mark1.gif', globals())
       mark2     = ImageFile('images/mark2.gif', globals())
       mark3     = ImageFile('images/mark3.gif', globals())
       mark4     = ImageFile('images/mark4.gif', globals())
       mark5     = ImageFile('images/mark5.gif', globals())
       mark6     = ImageFile('images/mark6.gif', globals())
       mark7     = ImageFile('images/mark7.gif', globals())
       mark8     = ImageFile('images/mark8.gif', globals())
       corner1   = ImageFile('images/olinks.gif', globals())
       corner2   = ImageFile('images/orechts.gif', globals())
       corner3   = ImageFile('images/ulinks.gif', globals())
       corner4   = ImageFile('images/urechts.gif', globals())    
   
   
       security.declareProtected('View','getLayout')
       def getLayout(self):
           """get Layout"""
           return self.layout
       
       def version(self):
           """version information"""
           return ZOGIVERSION
           
       def getContextStatic(self):
           """get all the contexts which go to static pages"""
           
     def generateImageFolder(self):          try:
         """images ablegen"""              dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
         self.manage_addFolder('images')              contexts=dom.getElementsByTagName("context")
         for image in os.listdir("../lib/python/Products/zogiLib/images"):  
             fn=file("../lib/python/Products/zogiLib/images/"+image)  
                           
             self.images.manage_addImage(image,fn)              ret=[]
               for context in contexts:
                   name=getUniqueElementText(context.getElementsByTagName("name"))
   
                   link=getUniqueElementText(context.getElementsByTagName("link"))
                   if name or link:
                       ret.append((name,link))
               return ret
           except:
               return []
                   
       def getContextDatabases(self):
           """get all dynamic contexts"""
           try:
               dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
               contexts=dom.getElementsByTagName("context")
               ret=[]
               for context in contexts:
                   metaDataLinks=context.getElementsByTagName("meta-datalink")
                   for metaDataLink in metaDataLinks:
                       db=metaDataLink.getAttribute("db")
                       link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
                       if db:
                           ret.append((db,link))
                   metaDataLinks=context.getElementsByTagName("meta-baselink")
   
                   for metaDataLink in metaDataLinks:
                       db=metaDataLink.getAttribute("db")
                       link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
                       if db:
                           ret.append((db,link))
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase):              return ret
         """init"""          except:
   
         self.id=id              return []
         self.title=title  
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase  
         self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))  
         self.generateImageFolder()  
   
   
     manage_options = Folder.manage_options+(      def formatHTML(self,url,label=None,viewUrl=None):
             {'label':'Main Config','action':'changeZogiLibForm'},  
             )  
   
     def option_js(self):          sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
         """option_js"""          ret=""
         ret="""function setParam(e) {          #print label
         if (document.all) s=e.srcElement;          if label:
                     else s=e.target;              ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
                         if (window.opener) location=window.opener.location          for set in sets:
                         else location=document.location              ret+="<table>"
                         location=" %s/setParam?"+s.name+'='+s.value;              for node in set.childNodes:
                         }"""%self.REQUEST['URL1']                  if hasattr(node,'tagName'):
                       tag=node.tagName
                       label=node.getAttribute("label")
                       if not label:
                           label=tag
                       text=getText(node.childNodes)
                       ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text)
               ret+="</table>"
         return ret          return ret
                                                   
                                                   
     def navigation_js(self):      def getMetaData(self):
         """Javascript"""          """getMetaData"""
                   try:
         return file("../lib/python/Products/zogiLib/js/navigation.js").read()              dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
           except:
               return "error metadata"
   
           contexts=dom.getElementsByTagName("context")
           ret=[]
           db=self.getDLParam("db")
           ob=self.getDLParam("object")
   
           fn=self.getDLParam("fn")
           pn=self.getDLParam("pn")
           if not fn:
               fn=""
           if not pn:
               pn=""
           if not ob:
               ob=""
                           
     def generateTopJavaScript(self):          for context in contexts:
         """generate script"""              metaDataLinks=context.getElementsByTagName("meta-datalink")
         ret="""var baseUrl = '%s'; """% self.REQUEST['URL0']              for metaDataLink in metaDataLinks:
         ret+="""newParameter('fn', '%s', '', 1);  
                 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+="""                  if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1):
   
         var wwidth, wheight;                      link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
         if (self.innerHeight) // all except Explorer                      label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
         {                      url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
         wwidth = self.innerWidth;  
         wheight = self.innerHeight;  
         }  
         else if (document.documentElement && document.documentElement.clientHeight)  
         // Explorer 6 Strict Mode  
         {  
         wwidth = document.documentElement.clientWidth;  
         wheight = document.documentElement.clientHeight;  
         }  
         else if (document.body) // other Explorers  
         {  
         wwidth = document.body.clientWidth;  
         wheight = document.body.clientHeight;  
         }  
   
         document.id="digilib"                      return self.formatHTML(link,label,url)
                   
         """              metaDataLinks=context.getElementsByTagName("meta-baselink")
         return ret  
   
               for metaDataLink in metaDataLinks:
   
                   if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1):
           
                       link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
                       label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
                       url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
                                   
                       return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
           return ret
                                   
                   
       def getDLInfo(self):
           """get DLInfo from digilib server"""
           paramH={}
           baseUrl=self.getDLBaseUrl()+"/dlInfo-xml.jsp"
           #print "getdlinfo: ", baseUrl
           try:
               url=urllib.urlopen(baseUrl+'?'+self.getAllDLParams())
               dom=xml.dom.minidom.parse(url)
               params=dom.getElementsByTagName('parameter')
               for param in params:
                   paramH[param.getAttribute('name')]=param.getAttribute('value')
               return paramH
           except:
               return {}
                   
     def generateScalerImg(self,requestString):  
         """generate Scaler Tag"""  
         retStr=self.digilibBaseUrl+requestString  
         jS="""<script type="text/javascript">  
         document.write("<img id=\\\"pic\\\" src=\\\"%s&dw="+wwidth+"&dh="+wheight+"\\\"/>")</script>"""%retStr  
         return jS  
   
     def changeZogiLibForm(self):      def zogilibPathOLD(self, otherbase=None):
         """Main configuration"""          """returns an URL to the zogiLib instance"""
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)          url = self.REQUEST['URL1']
         return pt()          # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           if type(otherbase) is str:
               url += otherbase
           else:
               url += self.basePath
           # should still end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
   
       def zogilibPath(self, otherbase=None):
           """returns an URL to the zogiLib instance"""
           url = self.absolute_url()
           # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           if type(otherbase) is str:
               url += otherbase
           else:
               url += self.basePath
           # should still end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
       def zogilibAction(self, action, otherbase=None):
           """returns a URL with zogilib path and action"""
           url = self.zogilibPath(otherbase)
           url += action
           url += '?' + self.getAllDLParams();
           return url
       
       def getDLBaseUrl(self):
           """returns digilib base URL (sans servlet path)"""
           if self.dlServerURL[-1] == '?':
               # full Servlet URL -- remove last part
               si = self.dlServerURL.rindex('/servlet/')
               if si > 0:
                   return self.dlServerURL[:si]
               else:
                   # no servlet part :-(
                   return "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary"
           else:
               return self.dlServerURL 
           
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):  
         """change it"""  
         self.title=title  
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase  
   
         if RESPONSE is not None:      def getScalerUrl(self,requestString=""):
             RESPONSE.redirect('manage_main')          """send scaler url"""
           if requestString is None:
               requestString = ""
           if self.dlServerURL[-1] == '?':
               # full Servlet URL
               return self.dlServerURL + requestString
           else:
               return self.dlServerURL+'/servlet/Scaler?'+requestString
   
       def scaledImage(self,requestString=None):
           """scaled Image"""
                           
     def nav_html(self,fileName):          if not requestString:
         """navigations frame"""              requestString=self.REQUEST['QUERY_STRING']
   
         # suche nach index.meta mit zogilib thumb info          self.REQUEST.RESPONSE.redirect(self.getScalerUrl(requestString))
           
           return True
       
           
       def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500, options=None):
           """generate Scaler IMG Tag"""
           self.checkQuery()
           bt = self.getBrowserType()
           # override with parameters from session
           if  self.REQUEST.SESSION.has_key('scalerDiv'):
               (requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']
           # if not explicitly defined take normal request
           url = self.getScalerUrl(requestString=requestString)
           # take insets from options if present
           if options is not None:
               side = options.get('side', side)
               bottom = options.get('bottom', bottom)
           # construct bottom and side insets
           b_par = ""
           s_par = ""
           if (bottom != 0) or (side != 0):
               b_par = "-" + str(int(bottom))
               s_par = "-" + str(int(side))
           tag = ""
           if bt['staticHTML']:
               tag += '<div id="scaler"><img id="pic" src="%s&dw=%i&dh=%i" /></div>'%(url, int(width-side), int(height-bottom))
           else:
               if bt['isN4']:
                   # N4 needs layers
                   tag += '<ilayer id="scaler">'
               else:
                   tag += '<div id="scaler">'
               tag += '<script type="text/javascript">'
               tag += "var ps = bestPicSize(getElement('scaler'));"
               # write img tag with javascript
               if requestString:
                   # take all parameters from requestString
                   tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\');'%(url, s_par, b_par)
               else:
                   # use javascript to filter digilib parameters
                   tag += """document.write('<img id="pic" src="%s'+getAllParameters(31)+'&dw='+(ps.width%s)+'&dh='+(ps.height%s)+'" />');"""%(url, s_par, b_par)
                   
         templ=readNavTemp(self.localFileBase+"/"+fileName)              tag += '</script>'
         if not templ:              if bt['isN4']:
             templ=readNavTemp(self.localFileBase+"/"+fileName.split("/")[0])                  tag += '</ilayer>'
             if not templ:              else:
                 return self.topTemplate.document_src()                  tag += '</div>'
           return tag
   
         return urllib.urlopen(templ).read()      def createScalerDiv(self, requestString = None, bottom = 0, side = 0, width=500, height=500):
           """generate scaler img and table with navigation arrows"""
           self.checkQuery()
           if requestString != None or bottom != 0 or side != 0:
               self.REQUEST.SESSION['scalerDiv'] = (requestString, bottom, side, width, height)
           else:
               if self.REQUEST.SESSION.has_key('scalerDiv'):
                   # make shure to remove unused parameter
                   del self.REQUEST.SESSION['scalerDiv']
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/img_div')).__of__(self)
           return pt()
           
     def index_html(self):      def index_html(self):
         """main action"""          """main action"""
           self.checkQuery()
           tp = "main_template"
           tpt = self.layout
           
           if not hasattr(self, 'template'):
               # create template folder if it doesn't exist
               print "no template folder -- creating"
               self.manage_addFolder('template')
   
           pt = getattr(self.template, 'main_'+tpt)
         pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_book.zpt').__of__(self)  
         return pt()          return pt()
   
     def storeQuery(self):      def checkQuery(self):
         """storeQuery in session"""          """make shure that the query has been saved"""
         self.REQUEST.SESSION['query']={}          if not self.REQUEST.has_key('dlParams'):
               self.storeQuery()
   
       def storeQuery(self, more=None, withpt=False):
           """parse query parameters into a hash in REQUEST"""
           params = {}
         for fm in self.REQUEST.form.keys():          for fm in self.REQUEST.form.keys():
             self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]              params[fm] = self.REQUEST.form[fm]
           # look for more
         self.REQUEST.SESSION['dlInfo']=self.getDlInfo()          if more:
                       for fm in more.split('&'):
     def getParam(self,param):  
         """Gebe Parameter aus"""  
         try:          try:
             return self.REQUEST.SESSION['query'][param]                      pv = fm.split('=')
                       params[pv[0]] = pv[1]
         except:          except:
             return None                      pass
   
     def getPageNum(self):          # parse digilib mode parameter
         """PAgenum"""          if 'mo' in params:
         pn=self.getParam('pn')              if len(params['mo']) > 0:
         if pn:                  modes=params['mo'].split(',')
             return pn  
         else:          else:
             return 1              modes = [];
   
     def biggerWS(self):          self.REQUEST.set('dlParams', params)
         """ws+1"""          self.REQUEST.set('dlModes', modes)
         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  
                   
           # trigger get pt (from dlInfo) if requested
           if withpt:
               pt = self.getPT()
                   
     def setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):          return params
         """setze Parameter"""  
         ret=""  
   
         if brgt:  
             self.REQUEST.SESSION['query']['brgt']=brgt  
   
         if cont:  
             self.REQUEST.SESSION['query']['cont']=cont  
   
         if pn:  
             self.REQUEST.SESSION['query']['pn']=pn  
   
         if ws:  
             self.REQUEST.SESSION['query']['ws']=ws  
   
         if rot:      def getDLParam(self, param, default=None):
             self.REQUEST.SESSION['query']['rot']=rot          """returns parameter or default"""
                       self.checkQuery()
         for param in self.REQUEST.SESSION['query'].keys():          dlParams = self.REQUEST.get('dlParams')
                       try:
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"              return dlParams[param]
                   except:
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)              return default
   
       def setDLParam(self, param, value):
           """sets parameter"""
           self.checkQuery()
           dlParams = self.REQUEST.get('dlParams')
           dlParams[param] = value
           return
         
     def mirrorPage(self,mi):      def getAllDLParams(self):
         """mirror"""          """parameter string for digilib"""
           self.checkQuery()
           dlParams = self.REQUEST.get('dlParams')
           # save modes
           modes = self.REQUEST.get('dlModes')
           if modes:
               dlParams['mo'] = string.join(modes, ',')
           # assemble query string
         ret=""          ret=""
         try:          for param in dlParams.keys():
             splitted=self.REQUEST.SESSION['query']['mo'].split(',')              if dlParams[param] is None: continue
         except:              val = str(dlParams[param])
             splitted=[]              if val != "":
                   ret += param + "=" + val + "&"
                   
         if mi=="h":          # omit trailing "&"
           return ret.rstrip('&')
                                           
             if 'hmir' in splitted:      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
                 splitted.remove('hmir')          """setze Parameter"""
             else:  
                 splitted.append('hmir')  
   
         if mi=="v":          self.setDLParam('brgt', brgt)
           self.setDLParam('cont', cont)
           self.setDLParam('ws', ws)
           self.setDLParam('rot', rot)
   
             if 'vmir' in splitted:          if pn:
                 splitted.remove('vmir')              # unmark
               self.setDLParam('mk', None)
               self.setDLParam('pn', pn)
               
           return self.display()
   
       def getBrowserType(self):
           """get browser type object"""
           if self.REQUEST.SESSION.has_key('browserType'):
               return self.REQUEST.SESSION['browserType']
             else:              else:
                 splitted.append('vmir')              bt = browserCheck(self)
               self.REQUEST.SESSION.set('browserType', bt)                        
               return bt
   
   
         self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")      def display(self):
           """(re)display page"""
           params = self.getAllDLParams()
                   
           if self.basePath:
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
           else:
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
                   
       def getMetaFileName(self):
           url=self.dlServerURL+'/dlContext-xml.jsp?'+self.getAllDLParams()
           return urlbase
   
       def getToolbarPageURL(self):
           """returns a toolbar-enabled page URL"""
           url=self.dlToolbarBaseURL+self.getAllDLParams()
           return url
       
       def getDLTarget(self):
           """returns dlTarget"""
           self.checkQuery()
           s = self.dlTarget
           if (s is None) or (s == ""):
   #            s = ""
               s = 'dl'
               if self.getDLParam('fn'):
                   s += "_" + self.getDLParam('fn')
               if self.getDLParam('pn'):
                   s += "_" + self.getDLParam('pn')
   
           return s
   
       def getPN(self):
           """pagenumber"""
           pn = int(self.getDLParam('pn', 1))
           return pn
                   
       def getPT(self):
           """number of total pages"""
           pt = self.getDLParam('pt', None)
           if pt is None:
               # get pt from dlInfo
               if self.REQUEST.has_key('dlInfo'):
                   info = self.REQUEST.get('dlInfo')
               else:
                   info = self.getDLInfo()
                   self.REQUEST.set('dlInfo', info)
               pt = int(info.get('pt', 1))
               self.setDLParam('pt', pt)
           return int(pt)
       
       def hasMode(self, mode):
           """returns if mode is in the diglib mo parameter"""
           return (mode in self.REQUEST.get('dlModes'))
   
       def hasNextPage(self):
           """returns if there is a next page"""
           pn = self.getPN()
           pt = self.getPT()
           return (pn < pt)
      
       def hasPrevPage(self):
           """returns if there is a previous page"""
           pn = self.getPN()
           return (pn > 1)
   
       def canMoveLeft(self):
           """returns if its possible to move left"""
           wx = float(self.getDLParam('wx') or 0)
           return (wx > 0)
   
       def canMoveRight(self):
           """returns if its possible to move right"""
           wx = float(self.getDLParam('wx') or 0)
           ww = float(self.getDLParam('ww') or 1)
           return (wx + ww < 1)
   
       def canMoveUp(self):
           """returns if its possible to move up"""
           wy = float(self.getDLParam('wy') or 0)
           return (wy > 0)
   
       def canMoveDown(self):
           """returns if its possible to move down"""
           wy = float(self.getDLParam('wy') or 0)
           wh = float(self.getDLParam('wh') or 1)
           return (wy + wh < 1)
   
   
       def dl_StaticHTML(self):
           """set rendering to static HTML"""
           self.checkQuery()
           self.getBrowserType()['staticHTML'] = True
           return self.display()
   
       def dl_DynamicHTML(self):
           """set rendering to dynamic HTML"""
           self.checkQuery()
           self.getBrowserType()['staticHTML'] = False
           return self.display()
           
       def dl_HMirror(self):
           """mirror action"""
           modes = self.getSubSession('dlModes')
           if 'hmir' in modes:
               modes.remove('hmir')
           else:
               modes.append('hmir')
                   
         for param in self.REQUEST.SESSION['query'].keys():          return self.display()
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      def dl_VMirror(self):
           """mirror action"""
           modes = self.getSubSession('dlModes')
           if 'vmir' in modes:
               modes.remove('vmir')
           else:
               modes.append('vmir')
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          return self.display()
                   
     def decode(self,strR):      def dl_Zoom(self, z):
         """decode &"""          """general zoom action"""
           ww1 = float(self.getDLParam('ww') or 1)
           wh1 = float(self.getDLParam('wh') or 1)
           wx = float(self.getDLParam('wx') or 0)
           wy = float(self.getDLParam('wy') or 0)
           ww2 = ww1 * z
           wh2 = wh1 * z
           wx += (ww1 - ww2) / 2
           wy += (wh1 - wh2) / 2
           ww2 = max(min(ww2, 1), 0)
           wh2 = max(min(wh2, 1), 0)
           wx = max(min(wx, 1), 0)
           wy = max(min(wy, 1), 0)
           self.setDLParam('ww', cropf(ww2))
           self.setDLParam('wh', cropf(wh2))
           self.setDLParam('wx', cropf(wx))
           self.setDLParam('wy', cropf(wy))
           return self.display()
           
       def dl_ZoomIn(self):
           """zoom in action"""
           z = 0.7071
           return self.dl_Zoom(z)
   
       def dl_ZoomOut(self):
           """zoom out action"""
           z = 1.4142
           return self.dl_Zoom(z)
   
       def dl_Move(self, dx, dy):
           """general move action"""
           ww = float(self.getDLParam('ww') or 1)
           wh = float(self.getDLParam('wh') or 1)
           wx = float(self.getDLParam('wx') or 0)
           wy = float(self.getDLParam('wy') or 0)
           wx += dx * 0.5 * ww
           wy += dy * 0.5 * wh
           wx = max(min(wx, 1), 0)
           wy = max(min(wy, 1), 0)
           self.setDLParam('wx', cropf(wx))
           self.setDLParam('wy', cropf(wy))
           return self.display()
           
       def dl_MoveLeft(self):
           """move left action"""
           return self.dl_Move(-1, 0)
       
       def dl_MoveRight(self):
           """move left action"""
           return self.dl_Move(1, 0)
       
       def dl_MoveUp(self):
           """move left action"""
           return self.dl_Move(0, -1)
       
       def dl_MoveDown(self):
           """move left action"""
           return self.dl_Move(0, 1)
       
       def dl_WholePage(self):
           """zoom out action"""
           self.setDLParam('ww', 1)
           self.setDLParam('wh', 1)
           self.setDLParam('wx', 0)
           self.setDLParam('wy', 0)
           return self.display()
           
       def dl_PrevPage(self):
           """next page action"""
           pn = self.getPN() - 1
           if pn < 1:
               pn = 1
           self.setDLParam('pn', pn)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
           
       def dl_NextPage(self):
           """next page action"""
           pn = self.getPN() + 1
           pt = self.getPT()
           if pn > pt:
               pn = pt
           self.setDLParam('pn', pn)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
   
       def dl_FirstPage(self):
           """first page action"""
           self.setDLParam('pn', 1)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
       
       def dl_LastPage(self):
           """last page action"""
           self.setDLParam('pn', self.getPT())
           # unmark
           self.setDLParam('mk', None)
           return self.display()
   
       def dl_db(self,db):
           """set db"""
           self.setDLParam('db',db)
           self.display()
                   
         return re.sub('\&amp','\&',strR)      def changeZogiLibForm(self):
           """Main configuration"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
           return pt()
           
     def wholePage(self):      def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
         """zoom out"""          """change it"""
         ret=""          self.title=title
           self.dlServerURL=dlServerURL
           self.basePath = basePath
           self.layout=version
           self.dlTarget = dlTarget
                   
         self.REQUEST.SESSION['query']['ww']=1          if dlToolbarBaseURL:
         self.REQUEST.SESSION['query']['wh']=1              self.dlToolbarBaseURL = dlToolbarBaseURL
         self.REQUEST.SESSION['query']['wx']=0          else:
         self.REQUEST.SESSION['query']['wy']=0              self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
                           
         for param in self.REQUEST.SESSION['query'].keys():          if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
                   
     def prevPage(self,pn=None):      ##
         """next page"""      ## odds and ends
         ret=""      ##
   
       def repairZogilib(self, obj=None):
           """change stuff that broke on upgrading"""
   
           msg = ""
   
           if not obj:
               obj = self.getPhysicalRoot()
   
           print "starting in ", obj
           
           entries=obj.ZopeFind(obj,obj_metatypes=['zogiLib'],search_sub=1)
   
           for entry in entries:
               print "  found ", entry
               #
               # replace digilibBaseUrl by dlServerURL
               if hasattr(entry[1], 'digilibBaseUrl'):
                   msg += "  fixing digilibBaseUrl in "+entry[0]+"\n"
                   entry[1].dlServerURL = re.sub('/servlet/Scaler\?','',entry[1].digilibBaseUrl)
                   del entry[1].digilibBaseUrl
                   
               #
               # add dlToolbarBaseURL
               if not hasattr(entry[1], 'dlToolbarBaseURL'):
                   msg += "  fixing dlToolbarBaseURL in "+entry[0]+"\n"
                   entry[1].dlToolbarBaseURL = entry[1].dlServerURL + "/digimage.jsp?"
   
         if pn and pn>0:          return msg+"\n\nfixed all zogilib instances in: "+obj.title
             pn=str(int(pn)-1)  
                   
   
         self.REQUEST.form['pn']=pn  def manage_addZogiLibForm(self):
       """interface for adding zogilib"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
       return pt()
                   
         for param in self.REQUEST.form.keys():  def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
       """add dgilib"""
       newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
       self.Destination()._setObject(id,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
                           
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  class zogiLibPageTemplate(ZopePageTemplate):
       """pageTemplate Objekt"""
       meta_type="zogiLib_pageTemplate"
   
     def firstPage(self):  
         """erste Seite"""  
         return self.setParam(pn="1")  
           
     def lastPage(self):  ## def __init__(self, id, text=None, contentType=None):
         """letzte Seite"""  ##         self.id = str(id)
   ##         self.ZBindings_edit(self._default_bindings)
   ##         if text is None:
   ##             text = open(self._default_cont).read()
   ##         self.pt_edit(text, contentType)
   
   def manage_addZogiLibPageTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
       return pt()
                   
     def nextPage(self,pn=None):  def manage_addZogiLibPageTemplate(self, title=None, layout=None, text=None,
         """next page"""                             REQUEST=None, submit=None):
         ret=""      "Add a Page Template with optional file content."
                   
       if not layout: layout = "book"
       id = 'main_%s'%layout
       self._setObject(id, zogiLibPageTemplate(id))
       ob = getattr(self, id)
       ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/main_%s.zpt'%layout)).read(),'text/html')
       if title:
           ob.pt_setTitle(title)
         try:          try:
             pn=str(int(pn)+1)          url = self.DestinationURL()
         except:      except AttributeError:
             pn=str(2)          url = REQUEST['URL1']
   
         self.REQUEST.form['pn']=pn  
           
         for param in self.REQUEST.form.keys():  
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
           
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
   
                   
 def manage_addZogiLibForm(self):      url = "%s/%s" % (url, urllib.quote(id))
     """interface for adding zogilib"""      REQUEST.RESPONSE.redirect(url+'/manage_main')
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiLibForm').__of__(self)      return ''
     return pt()  
   
 def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,RESPONSE=None):  
     """add dgilib"""  
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase)  
     self.Destination()._setObject(id,newObj)  
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
Removed from v.1.3  
changed lines
  Added in v.1.73

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