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

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

version 1.3, 2004/03/26 14:19:50 version 1.55.2.1, 2005/05/27 11:07:11
Line 1 Line 1
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   from OFS.Image import Image
   from AccessControl import ClassSecurityInfo
 import xml.dom.minidom  import xml.dom.minidom
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from xml_helpers import getText  from xml_helpers import getUniqueElementText,getText
 import os  import os
 import re  import re
 import string  import string
 import urllib  import urllib
   import types
   import random
 from Globals import package_home  from Globals import package_home
   
 def getString(self,key,default=''):  ZOGIVERSION = "0.10.1a ROC:27.5.2005"
     try:  
         return self.REQUEST[key]  
     except:  
         return default  
   
       
 class zogiLib_navTemplate(ZopePageTemplate):  
     """pageTemplate Objekt"""  
     meta_type="zogiLib_navTemplate"  
   
     _default_content_fn = os.path.join(package_home(globals()),  def cropf(f):
                                        'zpt/zogiLib_NavTemplateDefault.zpt')      """returns a float with reduced precision"""
       return float(int(f * 10000)/10000.0)
   
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'Copy to Filesystem','action':'copyContent'},  
        )  
   
     def getPath(self):  def sendFile(self, filename, type):
         """get path"""      """sends an object or a local file (from the product) as response"""
         return getPath(self,'thumbtemplate.templ')      paths = filename.split('/')
       object = self
       # look for an object called filename
       for path in paths:
           if hasattr(object, path):
           object = getattr(object, path)
       else:
           object = None
           break
       if object:
       # if the object exists then send it
       return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
       else:
       # send a local file with the given content-type
       fn = os.path.join(package_home(globals()), filename)
       self.REQUEST.RESPONSE.setHeader("Content-Type", type)
       self.REQUEST.RESPONSE.write(file(fn).read())
       return
           
     ## def changeECHO_pageTemplateWeightForm(self):  def browserCheck(self):
 ##         """change"""      """check the browsers request to find out the browser type"""
 ##         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self)      bt = {}
 ##         return pt()      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)
   
 ##     def changeECHO_pageTemplateWeight(self,weight,content_type,RESPONSE=None):      try:
 ##         """change"""          nav = ua[string.find(ua, '('):]
 ##         self.weight=weight          ie = string.split(nav, "; ")[1]
 ##         self.content_type=content_type          if string.find(ie, "MSIE") > -1:
               bt['versIE'] = string.split(ie, " ")[1]
       except: pass
       
       bt['isMac'] = string.find(ua, 'Macintosh') > -1
       bt['isWin'] = string.find(ua, 'Windows') > -1
       bt['isIEWin'] = bt['isIE'] and bt['isWin']
       bt['isIEMac'] = bt['isIE'] and bt['isMac']
       bt['staticHTML'] = False
   
       return bt
   
       
   class zogiImage(Image):
       """einzelnes Image"""
       meta_type="zogiImage"
   
 ##         if RESPONSE is not None:      manage_options=ZopePageTemplate.manage_options+(
 ##             RESPONSE.redirect('manage_main')          {'label':'Main config','action':'changeZogiImageForm'},
          )
                   
   
     def copyContent(self):      def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
         """copycontent to path"""          """init"""
           self.id=id
           self.title=title
           if baseUrl:
               self.baseUrl=baseUrl
           else:
               self.baseUrl="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?"
   
         return "copied to:"+copyContent(self,'thumbtemplate.templ')          self.queryString=queryString
           self.content_type=content_type
           self.precondition=precondition
                   
       def getData(self):
           """getUrlData"""
           return urllib.urlopen(self.baseUrl+self.queryString)
           
 def manage_addZogiLib_NavTemplateForm(self):      def changeZogiImageForm(self):
     """Form for adding"""          """Main configuration"""
     pt=PageTemplateFile('Products/zogiLib/zpt/AddZogilib_NavTemplate.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiImageForm.zpt')).__of__(self)
     return pt()      return pt()
   
       def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):
           """change it"""
           self.title=title
           self.baseUrl=baseUrl
           self.queryString=queryString
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def index_html(self, REQUEST, RESPONSE):
           """service the request by redirecting to digilib server"""
           RESPONSE.redirect(self.baseUrl+self.queryString)
           return ''
   
 def manage_addZogiLib_NavTemplate(self, id,title=None, text=None,  
                            REQUEST=None, submit=None):  
     "Add a Page Template with optional file content."  
   
           
     id = str(id)  def manage_addZogiImageForm(self):
     if REQUEST is None:      """Form for adding"""
         self._setObject(id, zogilib_NavTemplate(id, text))      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
         ob = getattr(self, id)      return pt()
                 
         if title:  
             ob.pt_setTitle(title)  
         return ob  
     else:  
         file = REQUEST.form.get('file')  
         headers = getattr(file, 'headers', None)  
         if headers is None or not file.filename:  
             zpt = zogilib_NavTemplate(id)  
         else:  
             zpt = zogilib_NavTemplate(id, file, headers.get('content_type'))  
   
         self._setObject(id, zpt)  def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
         ob = getattr(self, id)      """add zogiimage"""
       newObj=zogiImage(id,title,baseUrl, queryString)
       self.Destination()._setObject(id,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   
         try:  
             u = self.DestinationURL()  
         except AttributeError:  
             u = REQUEST['URL1']  
   
         if submit == " Add and Edit ":  class zogiLib(Folder):
             u = "%s/%s" % (u, quote(id))      """digilib frontend with ZOPE"""
         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?"
           
       security.declareProtected('View','getLayout')
       def getLayout(self):
           """get Layout"""
           return self.layout
       
       def version(self):
           """version information"""
           return ZOGIVERSION
           
     try:      def getContextStatic(self):
         navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)          """get all the contexts which go to static pages"""
     except:  
         navTag=None  
     return navTag  
           
           try:
               dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
               contexts=dom.getElementsByTagName("context")
                   
 class zogiLib(Folder):              ret=[]
     """StandardElement"""              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 []
   
     meta_type="zogiLib"      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 getDlInfo(self):              return ret
         """DLInfo"""          except:
         paramH={}  
         baseUrl=re.sub("servlet/Scaler","/dlInfo-xml.jsp",self.digilibBaseUrl)  
                   
         url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])              return []
         dom=xml.dom.minidom.parse(url)  
         params=dom.getElementsByTagName('parameter')  
         for param in params:  
             paramH[param.getAttribute('name')]=param.getAttribute('value')  
         return paramH  
   
     def getPageNumTotal(self):  
         """pagenums"""  
         return self.getDlInfo()['pt']  
           
       def formatHTML(self,url,label=None,viewUrl=None):
           
     def generateImageFolder(self):          sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
         """images ablegen"""          ret=""
         self.manage_addFolder('images')          print label
         for image in os.listdir("../lib/python/Products/zogiLib/images"):          if label:
             fn=file("../lib/python/Products/zogiLib/images/"+image)              ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
           for set in sets:
               ret+="<table>"
               for node in set.childNodes:
                   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
                           
             self.images.manage_addImage(image,fn)  
                   
       def getMetaData(self):
           """getMetaData"""
           try:
               dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
           except:
               return "error metadata"
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase):          contexts=dom.getElementsByTagName("context")
         """init"""          ret=[]
           db=self.getDLParam("db")
           ob=self.getDLParam("object")
   
         self.id=id          fn=self.getDLParam("fn")
         self.title=title          pn=self.getDLParam("pn")
         self.digilibBaseUrl=digilibBaseUrl          if not fn:
         self.localFileBase=localFileBase              fn=""
         self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))          if not pn:
         self.generateImageFolder()              pn=""
           if not ob:
               ob=""
   
           for context in contexts:
               metaDataLinks=context.getElementsByTagName("meta-datalink")
               for metaDataLink in metaDataLinks:
   
     manage_options = Folder.manage_options+(                  if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1):
             {'label':'Main Config','action':'changeZogiLibForm'},  
             )  
   
     def option_js(self):                      link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
         """option_js"""                      label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
         ret="""function setParam(e) {                      url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))
         if (document.all) s=e.srcElement;  
                     else s=e.target;  
                         if (window.opener) location=window.opener.location  
                         else location=document.location  
                         location=" %s/setParam?"+s.name+'='+s.value;  
                         }"""%self.REQUEST['URL1']  
         return ret  
                                                   
                       return self.formatHTML(link,label,url)
                                                   
     def navigation_js(self):              metaDataLinks=context.getElementsByTagName("meta-baselink")
         """Javascript"""  
                   
         return file("../lib/python/Products/zogiLib/js/navigation.js").read()              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"))
                           
     def generateTopJavaScript(self):                      return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
         """generate script"""          return ret
         ret="""var baseUrl = '%s'; """% self.REQUEST['URL0']  
         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+="""  
   
         var wwidth, wheight;      def getDLInfo(self):
         if (self.innerHeight) // all except Explorer          """get DLInfo from digilib server"""
         {          paramH={}
         wwidth = self.innerWidth;          baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
         wheight = self.innerHeight;          try:
         }              url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING'])
         else if (document.documentElement && document.documentElement.clientHeight)              dom=xml.dom.minidom.parse(url)
         // Explorer 6 Strict Mode              params=dom.getElementsByTagName('parameter')
         {              for param in params:
         wwidth = document.documentElement.clientWidth;                  paramH[param.getAttribute('name')]=param.getAttribute('value')
         wheight = document.documentElement.clientHeight;              return paramH
         }          except:
         else if (document.body) // other Explorers              return {}
         {  
         wwidth = document.body.clientWidth;  
         wheight = document.body.clientHeight;  
         }  
   
         document.id="digilib"  
                   
         """      def createHeadJS(self):
         return ret          """generate all javascript tags for head"""
       self.checkQuery()
       bt = self.REQUEST.SESSION.get('browserType', {})
           if bt['staticHTML']:
               return
   
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
           return pt()
   
       def createParamJS(self):
           """generate javascript for parameters only"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
           
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
           return pt()
                                   
                                   
       def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
           """generate Scaler IMG Tag"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           # 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
           if not requestString:
               requestString = self.getAllDLParams()
           url = self.dlServerURL+'/servlet/Scaler?'+requestString
           # 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
               tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\');'%(url, s_par, b_par)
               tag += '</script>'
               if bt['isN4']:
                   tag += '</ilayer>'
               else:
                   tag += '</div>'
           return tag
                   
       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']
                   
     def generateScalerImg(self,requestString):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
         """generate Scaler Tag"""          return pt()
         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 createAuxDiv(self):
         """Main configuration"""          """generate other divs"""
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)      self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
           if bt['isN4']:
               f = 'zpt/zogilib_divsN4.zpt'
           else:
               f = 'zpt/zogiLib_divs.zpt'
           pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self)
         return pt()          return pt()
           
     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 option_js(self):
             RESPONSE.redirect('manage_main')          """javascript"""
           return sendFile(self, 'js/option.js', 'text/plain')
   
       def dl_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/dllib.js', 'text/plain')
   
       def js_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/baselib.js', 'text/plain')
                           
     def nav_html(self,fileName):      def optionwindow(self):
         """navigations frame"""          """showoptions"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
           else:
               tp = "viewingTools.zpt"
               if hasattr(self, tp):
                   pt = getattr(self, tp)
           else:
                   pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
   
         # suche nach index.meta mit zogilib thumb info          return pt()
                   
         templ=readNavTemp(self.localFileBase+"/"+fileName)      def mark1(self):
         if not templ:          """mark image"""
             templ=readNavTemp(self.localFileBase+"/"+fileName.split("/")[0])          return sendFile(self, 'images/mark1.gif', 'image/gif')
             if not templ:  
                 return self.topTemplate.document_src()      def mark2(self):
           """mark image"""
           return sendFile(self, 'images/mark2.gif', 'image/gif')
   
       def mark3(self):
           """mark image"""
           return sendFile(self, 'images/mark3.gif', 'image/gif')
   
       def mark4(self):
           """mark image"""
           return sendFile(self, 'images/mark4.gif', 'image/gif')
   
       def mark5(self):
           """mark image"""
           return sendFile(self, 'images/mark5.gif', 'image/gif')
   
       def mark6(self):
           """mark image"""
           return sendFile(self, 'images/mark6.gif', 'image/gif')
   
       def mark7(self):
           """mark image"""
           return sendFile(self, 'images/mark7.gif', 'image/gif')
   
       def mark8(self):
           """mark image"""
           return sendFile(self, 'images/mark8.gif', 'image/gif')
   
       def corner1(self):
           """mark image"""
           return sendFile(self, 'images/olinks.gif', 'image/gif')
   
       def corner2(self):
           """mark image"""
           return sendFile(self, 'images/orechts.gif', 'image/gif')
   
       def corner3(self):
           """mark image"""
           return sendFile(self, 'images/ulinks.gif', 'image/gif')
   
       def corner4(self):
           """mark image"""
           return sendFile(self, 'images/urechts.gif', 'image/gif')
   
       def up_img(self):
           """mark image"""
           return sendFile(self, 'images/up.gif', 'image/gif')
   
       def down_img(self):
           """mark image"""
           return sendFile(self, 'images/down.gif', 'image/gif')
   
       def left_img(self):
           """mark image"""
           return sendFile(self, 'images/left.gif', 'image/gif')
   
       def right_img(self):
           """mark image"""
           return sendFile(self, 'images/right.gif', 'image/gif')
   
         return urllib.urlopen(templ).read()  
           
           
     def index_html(self):      def index_html(self):
         """main action"""          """main action"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           tp = "zogiLibMainTemplate"
   
           if hasattr(self, tp):
           pt = getattr(self, tp)
           else:
               tpt = self.layout
               
               if bt['staticHTML']:
                   tpt = "static"
                   
               pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)
   
         pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_book.zpt').__of__(self)  
         return pt()          return pt()
   
     def storeQuery(self):  
       def storeQuery(self, more = None):
         """storeQuery in session"""          """storeQuery in session"""
         self.REQUEST.SESSION['query']={}          dlParams = {}
         for fm in self.REQUEST.form.keys():          for fm in self.REQUEST.form.keys():
             self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]              dlParams[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('=')
                       dlParams[pv[0]] = pv[1]
         except:          except:
             return None                      pass
   
     def getPageNum(self):          # parse digilib mode parameter
         """PAgenum"""          if 'mo' in dlParams:
         pn=self.getParam('pn')              if len(dlParams['mo']) > 0:
         if pn:                  modes=dlParams['mo'].split(',')
             return pn  
         else:          else:
             return 1              modes=[]
   
     def biggerWS(self):  
         """ws+1"""  
         ws=self.getParam('ws')  
         if ws:  
             return int(ws)+1  
         else:  
             return 2  
   
     def options(self):          wid = self.getWID()
         """showoptions"""          self.REQUEST.set('wid', wid)
         pt=PageTemplateFile('Products/zogiLib/zpt/optionwindow.zpt').__of__(self)          self.setSubSession('dlQuery', dlParams)
         return pt()          self.setSubSession('dlModes', modes)
           self.setSubSession('dlInfo', self.getDLInfo())
           if not self.REQUEST.SESSION.has_key('browserType'):
               self.REQUEST.SESSION['browserType'] = browserCheck(self)
   
           return
                   
     def smallerWS(self):      def checkQuery(self):
         """ws-11"""      """check if the query has been stored"""
         ws=self.getParam('ws')      if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) :
         if ws:          print "ZOGILIB: have to store query!!"
             if int(ws)==1:          self.storeQuery()
                 return                  return
   
       def zogilibPath(self, otherbase=None):
           """returns an URL to the zogiLib instance"""
           url = self.REQUEST['URL1']
           # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           if type(otherbase) is str:
               url += otherbase
             else:              else:
                 return int(ws)-1              url += self.basePath
           # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
   
       def zogilibAction(self, action, otherbase=None, wid=None):
           """returns a URL with zogilib path, action and wid"""
           url = self.zogilibPath(otherbase)
           url += action
           if wid:
               url += '?wid=' + wid
         else:          else:
             return 1              url += '?wid=' + self.getWID()
                   return url
                   
     def setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):      def getSubSession(self, key, default=None):
         """setze Parameter"""          """returns an element from a session with a wid"""
         ret=""          wid = self.getWID()
           return self.REQUEST.SESSION.get(key+'_'+wid, default)
   
       def setSubSession(self, key, value):
           """puts an element in a session with a wid"""
           wid = self.getWID()
           self.REQUEST.SESSION.set(key+'_'+wid, value)
           return
   
         if brgt:      def getWID(self):
             self.REQUEST.SESSION['query']['brgt']=brgt          """returns a (new) window id"""
           wid = self.REQUEST.get('wid')
           if not wid:
               wid = 'digi_'+str(int(random.random()*10000))
               print "new WID:", wid
           return wid
   
         if cont:      def getDLParam(self, param, default=None):
             self.REQUEST.SESSION['query']['cont']=cont          """returns parameter or default"""
           try:
               return self.getSubSession('dlQuery').get(param, default)
           except:
               return default
   
         if pn:      def setDLParam(self, param, value):
             self.REQUEST.SESSION['query']['pn']=pn          """sets parameter"""
           dlParams = self.getSubSession('dlQuery')
           #try:
           dlParams[param] = value
           #except:
           #    self.setSubSession('dlQuery', {param: value})
           return
   
         if ws:      def getAllDLParams(self):
             self.REQUEST.SESSION['query']['ws']=ws          """parameter string for digilib"""
           dlParams = self.getSubSession('dlQuery')
           # save modes
           modes = self.getSubSession('dlModes')
           dlParams['mo'] = string.join(modes, ',')
           # assemble query string
           ret = ""
           for param in dlParams.keys():
               if dlParams[param] is None: continue
               val = str(dlParams[param])
               if val != "":
                   ret += param + "=" + val + "&"
   
         if rot:          # omit trailing "&"
             self.REQUEST.SESSION['query']['rot']=rot          return ret.rstrip('&')
                           
         for param in self.REQUEST.SESSION['query'].keys():  
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
           """setze Parameter"""
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)          self.setDLParam('brgt', brgt)
           self.setDLParam('cont', cont)
           self.setDLParam('ws', ws)
           self.setDLParam('rot', rot)
   
           if pn:
               # unmark
               self.setDLParam('mk', None)
               self.setDLParam('pn', pn)
         
     def mirrorPage(self,mi):          return self.display()
         """mirror"""  
         ret=""  
         try:  
             splitted=self.REQUEST.SESSION['query']['mo'].split(',')  
         except:  
             splitted=[]  
                   
         if mi=="h":  
                                           
             if 'hmir' in splitted:      def display(self):
                 splitted.remove('hmir')          """(re)display page"""
             else:          if not self.getDLParam('wid'):
                 splitted.append('hmir')              wid = self.getWID()
               self.setDLParam('wid', wid)
   
         if mi=="v":          params = self.getAllDLParams()
   
             if 'vmir' in splitted:          if self.basePath:
                 splitted.remove('vmir')              self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
             else:              else:
                 splitted.append('vmir')              self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
   
   
         self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")  
                   
       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 == None:
               s = ""
   #         s = 'dl'
   #         if self.getDLParam('fn'):
   #             s += "_" + self.getDLParam('fn')
   #         if self.getDLParam('pn'):
   #             s += "_" + self.getDLParam('pn')
           return s
   
       def setStaticHTML(self, static=True):
           """sets the preference to static HTML"""
           self.checkQuery()
       self.REQUEST.SESSION['browserType']['staticHTML'] = static
           return
                   
       def isStaticHTML(self):
           """returns if the page is using static HTML only"""
           self.checkQuery()
       return self.REQUEST.SESSION['browserType']['staticHTML']
                   
       def getPT(self):
           """pagenums"""
           di = self.getSubSession('dlInfo')
           if di:
               return int(di['pt'])
           else:
               return 1
                   
         for param in self.REQUEST.SESSION['query'].keys():      def getPN(self):
           """Pagenum"""
           pn = self.getDLParam('pn')
           try:
               return int(pn)
           except:
               return 1
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      def getBiggerWS(self):
           """ws+1"""
           ws = self.getDLParam('ws')
           try:
               return float(ws)+0.5
           except:
               return 1.5
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      def getSmallerWS(self):
           """ws-1"""
           ws=self.getDLParam('ws')
           try:
               return max(float(ws)-0.5, 1)
           except:
               return 1
                   
     def decode(self,strR):      def hasMode(self, mode):
         """decode &"""          """returns if mode is in the diglib mo parameter"""
           wid = self.getWID()
           return (mode in self.REQUEST.SESSION['dlModes_'+wid])
   
       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.REQUEST.SESSION['browserType']['staticHTML'] = True
           return self.display()
   
       def dl_DynamicHTML(self):
           """set rendering to dynamic HTML"""
           self.checkQuery()
           self.REQUEST.SESSION['browserType']['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')
                   
         return re.sub('\&amp','\&',strR)          return self.display()
           
     def wholePage(self):      def dl_VMirror(self):
         """zoom out"""          """mirror action"""
         ret=""          modes = self.getSubSession('dlModes')
           if 'vmir' in modes:
               modes.remove('vmir')
           else:
               modes.append('vmir')
                   
         self.REQUEST.SESSION['query']['ww']=1          return self.display()
         self.REQUEST.SESSION['query']['wh']=1  
         self.REQUEST.SESSION['query']['wx']=0  
         self.REQUEST.SESSION['query']['wy']=0  
                           
         for param in self.REQUEST.SESSION['query'].keys():      def dl_Zoom(self, z):
           """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_Unmark(self):
           """action to remove last mark"""
           mk = self.getDLParam('mk')
           if mk:
               marks = mk.split(',')
               marks.pop()
               mk = string.join(marks, ',')
               self.setDLParam('mk', mk)
           return self.display()
   
       def dl_db(self,db):
           """set db"""
           self.setDLParam('db',db)
           self.display()
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      def changeZogiLibForm(self):
           """Main configuration"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
           return pt()
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
           """change it"""
           self.title=title
           self.dlServerURL=dlServerURL
           self.basePath = basePath
           self.layout=version
           self.dlTarget = dlTarget
                   
     def prevPage(self,pn=None):          if dlToolbarBaseURL:
         """next page"""              self.dlToolbarBaseURL = dlToolbarBaseURL
         ret=""          else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
         if pn and pn>0:          if RESPONSE is not None:
             pn=str(int(pn)-1)              RESPONSE.redirect('manage_main')
                   
   
         self.REQUEST.form['pn']=pn  
                   
         for param in self.REQUEST.form.keys():      ##
       ## odds and ends
       ##
   
       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?"
                           
             ret+=param+"="+str(self.REQUEST.form[param])+"&"          return msg+"\n\nfixed all zogilib instances in: "+obj.title
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
   
     def firstPage(self):  def manage_addZogiLibForm(self):
         """erste Seite"""      """interface for adding zogilib"""
         return self.setParam(pn="1")      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
       return pt()
           
     def lastPage(self):  def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
         """letzte Seite"""      """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')
   
                   
     def nextPage(self,pn=None):  class zogiLibPageTemplate(ZopePageTemplate):
         """next page"""      """pageTemplate Objekt"""
         ret=""      meta_type="zogiLib_pageTemplate"
                   
         try:  
             pn=str(int(pn)+1)  
         except:  
             pn=str(2)  
   
         self.REQUEST.form['pn']=pn  ## def __init__(self, id, text=None, contentType=None):
   ##         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)
                   
         for param in self.REQUEST.form.keys():  def manage_addZogiLibPageTemplateForm(self):
             ret+=param+"="+str(self.REQUEST.form[param])+"&"      """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
       return pt()
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,
                              REQUEST=None, submit=None):
       "Add a Page Template with optional file content."
   
       id = str(id)
       self._setObject(id, zogiLibPageTemplate(id))
       ob = getattr(self, id)
       if not layout: layout = "book"
       ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/zogiLibMain_%s.zpt'%layout)).read(),None)
       if title:
           ob.pt_setTitle(title)
       try:
           u = self.DestinationURL()
       except AttributeError:
           u = REQUEST['URL1']
                   
 def manage_addZogiLibForm(self):      u = "%s/%s" % (u, urllib.quote(id))
     """interface for adding zogilib"""      REQUEST.RESPONSE.redirect(u+'/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.55.2.1

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