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

Diff for /zogiLib/zogiLib.py between versions 1.22 and 1.38

version 1.22, 2004/06/03 18:05:57 version 1.38, 2004/07/23 16:01:28
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
Line 7  from webdav.common import rfc1123_date Line 6  from webdav.common import rfc1123_date
   
 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
 from Globals import package_home  from Globals import package_home
   
 def getString(self,key,default=''):  ZOGIVERSION = "0.9.7 ROC:23.7.2004"
     try:  
         return self.REQUEST[key]  def cropf(f):
     except:      """returns a float with reduced precision"""
         return default      return float(int(f * 10000)/10000.0)
   
   
 def sendFile(self, filename, type):  def sendFile(self, filename, type):
     """sends an object or a local file (in the product) as response"""      """sends an object or a local file (in the product) as response"""
Line 41  def sendFile(self, filename, type): Line 42  def sendFile(self, filename, type):
     self.REQUEST.RESPONSE.write(file(fn).read())      self.REQUEST.RESPONSE.write(file(fn).read())
     return      return
   
 class BrowserCheck:  def browserCheck(self):
     """check the browsers request to find out the browser type"""      """check the browsers request to find out the browser type"""
           bt = {}
     def __init__(self, zope):      ua = self.REQUEST.get_header("HTTP_USER_AGENT")
     self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")      bt['ua'] = ua
     self.isIE = string.find(self.ua, 'MSIE') > -1      bt['isIE'] = string.find(ua, 'MSIE') > -1
     self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and not self.isIE      bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1) and not bt['isIE']
     self.nav = self.ua[string.find(self.ua, '('):]      nav = ua[string.find(ua, '('):]
     ie = string.split(self.nav, "; ")[1]      ie = string.split(nav, "; ")[1]
     if string.find(ie, "MSIE") > -1:      if string.find(ie, "MSIE") > -1:
         self.versIE = string.split(ie, " ")[1]          bt['versIE'] = string.split(ie, " ")[1]
     self.isMac = string.find(self.ua, 'Macintosh') > -1      bt['isMac'] = string.find(ua, 'Macintosh') > -1
     self.isWin = string.find(self.ua, 'Windows') > -1      bt['isWin'] = string.find(ua, 'Windows') > -1
     self.isIEWin = self.isIE and self.isWin      bt['isIEWin'] = bt['isIE'] and bt['isWin']
     self.isIEMac = self.isIE and self.isMac      bt['isIEMac'] = bt['isIE'] and bt['isMac']
       bt['staticHTML'] = False
   
 def manage_addZogiLibMainTemplateForm(self):  
     """Form for adding"""  
     #FIXME:???  
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/AddOSAS_thumbTemplate.zpt')).__of__(self)  
     return pt()  
   
   
   
       return bt
 def manage_addZogiLibMainTemplate(self, id,title=None, text=None,  
                            REQUEST=None, submit=None):  
     "Add a Page Template with optional file content."  
     #FIXME:???  
     id = str(id)  
     if REQUEST is None:  
         self._setObject(id, zogiLib_mainTemplate(id, text))  
         ob = getattr(self, id)  
          
         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_mainTemplate(id)  
         else:  
             zpt = zogiLib_mainTemplate(id, file, headers.get('content_type'))  
   
         self._setObject(id, zpt)  
         ob = getattr(self, id)  
   
   
         try:  
             u = self.DestinationURL()  
         except AttributeError:  
             u = REQUEST['URL1']  
   
         if submit == " Add and Edit ":  
             u = "%s/%s" % (u, quote(id))  
         REQUEST.RESPONSE.redirect(u+'/manage_main')  
     return ''  
   
           
 class zogiImage(Image):  class zogiImage(Image):
Line 422  class zogiLib(Folder): Line 382  class zogiLib(Folder):
     """StandardElement"""      """StandardElement"""
   
     meta_type="zogiLib"      meta_type="zogiLib"
       #xxxx
   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
             {'label':'Main Config','action':'changeZogiLibForm'},              {'label':'Main Config','action':'changeZogiLibForm'},
             )              )
   
     def __init__(self, id, title, digilibBaseUrl, localFileBase, version="book", basePath=""):      def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
         """init"""          """init"""
   
         self.id=id          self.id=id
         self.title=title          self.title=title
         self.digilibBaseUrl=digilibBaseUrl          self.dlServerURL = dlServerURL
         self.localFileBase=localFileBase  
         self.basePath=basePath          self.basePath=basePath
         self.layout=version          self.layout=layout
           if dlTarget:
               self.dlTarget = dlTarget
           else:
               self.dlTarget = "digilib"
   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
   
       def version(self):
           """version information"""
           return ZOGIVERSION
   
       def getContextStatic(self):
           """get all the contexts which go to static pages"""
   
           try:
               dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
               contexts=dom.getElementsByTagName("context")
   
               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))
   
               return ret
           except:
               return ret
   
       def formatHTML(self,url,label=None,viewUrl=None):
   
   
           sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
           ret=""
           print label
           if label:
               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
       
       def getMetaData(self):
           """getMetaData"""
           try:
               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=""
               
           for context in contexts:
               metaDataLinks=context.getElementsByTagName("meta-datalink")
               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,label,url)
   
               metaDataLinks=context.getElementsByTagName("meta-baselink")
                
               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):      def getDLInfo(self):
         """get DLInfo from digilib server"""          """get DLInfo from digilib server"""
         paramH={}          paramH={}
         baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)          baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
         try:          try:
             url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])              url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])
             dom=xml.dom.minidom.parse(url)              dom=xml.dom.minidom.parse(url)
Line 450  class zogiLib(Folder): Line 533  class zogiLib(Folder):
                 paramH[param.getAttribute('name')]=param.getAttribute('value')                  paramH[param.getAttribute('name')]=param.getAttribute('value')
             return paramH              return paramH
         except:          except:
             return null              return {}
   
   
     def createHeadJS(self):      def createHeadJS(self):
         """generate all javascript tags for head"""          """generate all javascript tags for head"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
           
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
         return pt()          return pt()
   
     def createParamJS(self):      def createParamJS(self):
         """generate javascript for parameters only"""          """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)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
         return pt()          return pt()
                   
                                                   
     def createScalerImg(self, requestString = None, bottom = 0, side = 0):      def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
         """generate Scaler IMG Tag"""          """generate Scaler IMG Tag"""
     self.checkQuery()      self.checkQuery()
     bt = self.REQUEST.SESSION['browserType']      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:          if not requestString:
             requestString = self.getAllDLParams()              requestString = self.getAllDLParams()
         url = self.digilibBaseUrl+requestString          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 = ""          tag = ""
         if bt.isN4:          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">'              tag += '<ilayer id="scaler">'
         else:          else:
             tag += '<div id="scaler">'              tag += '<div id="scaler">'
         tag += '<script type="text/javascript">'          tag += '<script type="text/javascript">'
         tag += "var ps = bestPicSize(getElement('scaler'));"          tag += "var ps = bestPicSize(getElement('scaler'));"
         b_par = ""              # write img tag with javascript
         s_par = ""              tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\');'%(url, s_par, b_par)
         if (bottom != 0) or (side != 0):  
             b_par = "-" + str(int(bottom))  
             s_par = "-" + str(int(side))  
         tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\')'%(url, s_par, b_par)  
         tag += '</script>'          tag += '</script>'
         if bt.isN4:              if bt['isN4']:
             tag += '</ilayer>'              tag += '</ilayer>'
         else:          else:
             tag += '</div>'              tag += '</div>'
         return tag          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']
                   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
           return pt()
   
     def createAuxDiv(self):      def createAuxDiv(self):
         """generate other divs"""          """generate other divs"""
     self.checkQuery()      self.checkQuery()
     bt = self.REQUEST.SESSION['browserType']      bt = self.REQUEST.SESSION['browserType']
         if bt.isN4:          if bt['staticHTML']:
               return
           if bt['isN4']:
             f = 'zpt/zogilib_divsN4.zpt'              f = 'zpt/zogilib_divsN4.zpt'
         else:          else:
             f = 'zpt/zogilib_divs.zpt'              f = 'zpt/zogilib_divs.zpt'
Line 504  class zogiLib(Folder): Line 622  class zogiLib(Folder):
   
   
     def option_js(self):      def option_js(self):
         """option_js"""          """javascript"""
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/option_js')).__of__(self)          return sendFile(self, 'js/option.js', 'text/plain')
         return pt()  
   
     def dl_lib_js(self):      def dl_lib_js(self):
         """javascript"""          """javascript"""
         return sendFile(self, 'js/dl_lib.js', 'text/plain')          return sendFile(self, 'js/dllib.js', 'text/plain')
   
     def js_lib_js(self):      def js_lib_js(self):
         """javascript"""          """javascript"""
         return sendFile(self, 'js/js_lib.js', 'text/plain')          return sendFile(self, 'js/baselib.js', 'text/plain')
   
     def optionwindow(self):      def optionwindow(self):
         """showoptions"""          """showoptions"""
       self.checkQuery()
           if self.REQUEST.has_key('frametarget'):
               self.dlTarget = self.REQUEST['frametarget']
       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)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
                   
         return pt()          return pt()
   
     def mark1(self):      def mark1(self):
Line 589  class zogiLib(Folder): Line 718  class zogiLib(Folder):
                           
     def index_html(self):      def index_html(self):
         """main action"""          """main action"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
         tp = "zogiLibMainTemplate"          tp = "zogiLibMainTemplate"
           
         if hasattr(self, tp):          if hasattr(self, tp):
         pt = getattr(self, tp)          pt = getattr(self, tp)
         else:          else:
             pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%self.layout)).__of__(self)              tpt = self.layout
               
               if bt['staticHTML']:
                   tpt = "static"
                   
               pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)
               
         return pt()          return pt()
   
   
Line 610  class zogiLib(Folder): Line 748  class zogiLib(Folder):
                     pv = fm.split('=')                      pv = fm.split('=')
                     dlParams[pv[0]] = pv[1]                      dlParams[pv[0]] = pv[1]
                 except:                  except:
                     print "ouch!"                      pass
                   
         # parse digilib mode parameter          # parse digilib mode parameter
         if 'mo' in dlParams:          if 'mo' in dlParams:
             if len(dlParams['mo']) > 0:              if len(dlParams['mo']) > 0:
Line 621  class zogiLib(Folder): Line 760  class zogiLib(Folder):
         self.REQUEST.SESSION['query'] = dlParams          self.REQUEST.SESSION['query'] = dlParams
         self.REQUEST.SESSION['dlModes'] = modes          self.REQUEST.SESSION['dlModes'] = modes
         self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()          self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()
         self.REQUEST.SESSION['browserType'] = BrowserCheck(self)          if not self.REQUEST.SESSION.has_key('browserType'):
               self.REQUEST.SESSION['browserType'] = browserCheck(self)
               
           return
   
     def checkQuery(self):      def checkQuery(self):
     """check if the query has been stored"""      """check if the query has been stored"""
     if not (self.REQUEST.SESSION):      if not (self.REQUEST.SESSION and self.REQUEST.SESSION.has_key('query')) :
         print "ZOGILIB: have to store query!!"          print "ZOGILIB: have to store query!!"
         storeQuery(self)          self.storeQuery()
           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:
               url += self.basePath
           # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
                   
     def getDLParam(self, param):      def getDLParam(self, param):
         """returns parameter"""          """returns parameter"""
         try:          try:
             return self.REQUEST.SESSION['query'][param]              return self.REQUEST.SESSION['query'][param]
         except:          except:
             return None              return
   
     def setDLParam(self, param, value):      def setDLParam(self, param, value):
         """sets parameter"""          """sets parameter"""
Line 650  class zogiLib(Folder): Line 808  class zogiLib(Folder):
         # assemble query string          # assemble query string
         ret = ""          ret = ""
         for param in dlParams.keys():          for param in dlParams.keys():
               if dlParams[param] is None: continue
             val = str(dlParams[param])              val = str(dlParams[param])
             if val != "":              if val != "":
                 ret += param + "=" + val + "&"                  ret += param + "=" + val + "&"
   
         # omit trailing "&"          # omit trailing "&"
         return ret.rstrip('&')          return ret.rstrip('&')
   
                   
     def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
         """setze Parameter"""          """setze Parameter"""
         ret=""  
   
         if brgt:  
             self.setDLParam('brgt', brgt)              self.setDLParam('brgt', brgt)
   
         if cont:  
             self.setDLParam('cont', cont)              self.setDLParam('cont', cont)
           self.setDLParam('ws', ws)
           self.setDLParam('rot', rot)
   
         if pn:          if pn:
             # unmark              # unmark
             self.setDLParam('mk', None)              self.setDLParam('mk', None)
             self.setDLParam('pn', pn)              self.setDLParam('pn', pn)
   
         if ws:  
             self.setDLParam('ws', ws)  
   
         if rot:  
             self.setDLParam('rot', rot)  
               
         return self.display()          return self.display()
   
   
Line 689  class zogiLib(Folder): Line 841  class zogiLib(Folder):
         else:          else:
             self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)              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
   #         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):      def getPT(self):
         """pagenums"""          """pagenums"""
         di = self.REQUEST.SESSION['dlInfo']          di = self.REQUEST.SESSION['dlInfo']
Line 700  class zogiLib(Folder): Line 883  class zogiLib(Folder):
     def getPN(self):      def getPN(self):
         """Pagenum"""          """Pagenum"""
         pn = self.getDLParam('pn')          pn = self.getDLParam('pn')
         if pn:          try:
             return int(pn)              return int(pn)
         else:          except:
             return 1              return 1
   
     def getBiggerWS(self):      def getBiggerWS(self):
         """ws+1"""          """ws+1"""
         ws=self.getDLParam('ws')          ws=self.getDLParam('ws')
         if ws:          try:
             return int(ws)+1              return float(ws)+0.5
         else:          except:
             return 2              return 1.5
                   
     def getSmallerWS(self):      def getSmallerWS(self):
         """ws-1"""          """ws-1"""
         ws=self.getDLParam('ws')          ws=self.getDLParam('ws')
         if ws:          try:
             if int(ws)==1:              return max(float(ws)-0.5, 1)
                 return 1          except:
             else:  
                 return int(ws)-1  
         else:  
             return 1              return 1
   
     def hasMode(self, mode):      def hasMode(self, mode):
Line 762  class zogiLib(Folder): Line 942  class zogiLib(Folder):
         return (wy + wh < 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):      def dl_HMirror(self):
         """mirror action"""          """mirror action"""
         modes = self.REQUEST.SESSION['dlModes']          modes = self.REQUEST.SESSION['dlModes']
Line 796  class zogiLib(Folder): Line 988  class zogiLib(Folder):
         wh2 = max(min(wh2, 1), 0)          wh2 = max(min(wh2, 1), 0)
         wx = max(min(wx, 1), 0)          wx = max(min(wx, 1), 0)
         wy = max(min(wy, 1), 0)          wy = max(min(wy, 1), 0)
         self.setDLParam('ww', ww2)          self.setDLParam('ww', cropf(ww2))
         self.setDLParam('wh', wh2)          self.setDLParam('wh', cropf(wh2))
         self.setDLParam('wx', wx)          self.setDLParam('wx', cropf(wx))
         self.setDLParam('wy', wy)          self.setDLParam('wy', cropf(wy))
         return self.display()          return self.display()
                   
     def dl_ZoomIn(self):      def dl_ZoomIn(self):
Line 822  class zogiLib(Folder): Line 1014  class zogiLib(Folder):
         wy += dy * 0.5 * wh          wy += dy * 0.5 * wh
         wx = max(min(wx, 1), 0)          wx = max(min(wx, 1), 0)
         wy = max(min(wy, 1), 0)          wy = max(min(wy, 1), 0)
         self.setDLParam('wx', wx)          self.setDLParam('wx', cropf(wx))
         self.setDLParam('wy', wy)          self.setDLParam('wy', cropf(wy))
         return self.display()          return self.display()
                   
     def dl_MoveLeft(self):      def dl_MoveLeft(self):
Line 895  class zogiLib(Folder): Line 1087  class zogiLib(Folder):
             self.setDLParam('mk', mk)              self.setDLParam('mk', mk)
         return self.display()          return self.display()
   
       def dl_db(self,db):
           """set db"""
           self.setDLParam('db',db)
           self.display()
   
     def changeZogiLibForm(self):      def changeZogiLibForm(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
         return pt()          return pt()
           
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase, version, basePath, RESPONSE=None):      def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
         """change it"""          """change it"""
         self.title=title          self.title=title
         self.digilibBaseUrl=digilibBaseUrl          self.dlServerURL=dlServerURL
         self.localFileBase=localFileBase  
         self.basePath = basePath          self.basePath = basePath
         self.layout=version          self.layout=version
           if dlTarget:
               self.dlTarget = dlTarget
           else:
               self.dlTarget = "digilib"
   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
                       
   
       ##
       ## odd stuff
       ##
   
       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?"
                   
           return msg+"\n\nfixed all zogilib instances in: "+obj.title
   
             
 def manage_addZogiLibForm(self):  def manage_addZogiLibForm(self):
     """interface for adding zogilib"""      """interface for adding zogilib"""
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
     return pt()      return pt()
   
 def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",basePath="",RESPONSE=None):  def manage_addZogiLib(self,id,title,dlServerURL,layout="book",basePath="",dlTarget="digilib",dlToolbarBaseURL=None,RESPONSE=None):
     """add dgilib"""      """add dgilib"""
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version, basePath)      newObj=zogiLib(id,title,dlServerURL, localFileBase, version, basePath, dlTarget, dlToolbarBaseURL)
     self.Destination()._setObject(id,newObj)      self.Destination()._setObject(id,newObj)
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   class zogiLibPageTemplate(ZopePageTemplate):
       """pageTemplate Objekt"""
       meta_type="zogiLib_pageTemplate"
   
   
   ## 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)
   
   def manage_addZogiLibPageTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
       return pt()
   
   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']
           
       u = "%s/%s" % (u, urllib.quote(id))
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
Removed from v.1.22  
changed lines
  Added in v.1.38

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