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

Diff for /zogiLib/zogiLib.py between versions 1.9 and 1.25

version 1.9, 2004/04/22 08:24:14 version 1.25, 2004/06/04 16:07:49
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 11  import os Line 12  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=''):  def getString(self,key,default=''):
Line 19  def getString(self,key,default=''): Line 21  def getString(self,key,default=''):
     except:      except:
         return default          return default
   
       def sendFile(self, filename, type):
 class zogiLib_navTemplate(ZopePageTemplate):      """sends an object or a local file (in the product) as response"""
     """pageTemplate Objekt"""      paths = filename.split('/')
     meta_type="zogiLib_navTemplate"      object = self
       # look for an object called filename
     _default_content_fn = os.path.join(package_home(globals()),      for path in paths:
                                        'zpt/zogiLib_NavTemplateDefault.zpt')          if hasattr(object, path):
           object = getattr(object, path)
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'Copy to Filesystem','action':'copyContent'},  
        )  
   
     def getPath(self):  
         """get path"""  
         return getPath(self,'thumbtemplate.templ')  
       
   
     def copyContent(self):  
         """copycontent to path"""  
   
         return "copied to:"+copyContent(self,'thumbtemplate.templ')  
           
       
 def manage_addZogiLib_NavTemplateForm(self):  
     """Form for adding"""  
     pt=PageTemplateFile('Products/zogiLib/zpt/AddZogilib_NavTemplate.zpt').__of__(self)  
     return pt()  
   
   
   
   
 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)  
     if REQUEST is None:  
         self._setObject(id, zogilib_NavTemplate(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_NavTemplate(id)  
         else:  
             zpt = zogilib_NavTemplate(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 ''  
   
   
           
 def readNavTemp(fileName):  
     """navtemp"""  
       
       
     if os.path.exists(fileName+"/index.meta"):  
         dom=xml.dom.minidom.parse(fileName+"/index.meta")  
     else:      else:
         return None          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
           
   class BrowserCheck:
       """check the browsers request to find out the browser type"""
           
     try:      def __init__(self, zope):
         navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)      self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
     except:      self.isIE = string.find(self.ua, 'MSIE') > -1
         navTag=None      self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and not self.isIE
     return navTag      self.nav = self.ua[string.find(self.ua, '('):]
       ie = string.split(self.nav, "; ")[1]
 class zogiLib_mainTemplate(ZopePageTemplate):      if string.find(ie, "MSIE") > -1:
     """pageTemplate Objekt"""          self.versIE = string.split(ie, " ")[1]
     meta_type="zogiLib_mainTemplate"      self.isMac = string.find(self.ua, 'Macintosh') > -1
       self.isWin = string.find(self.ua, 'Windows') > -1
           self.isIEWin = self.isIE and self.isWin
     def __init__(self, id, text=None, content_type=None, version="book"):      self.isIEMac = self.isIE and self.isMac
   
         default_content_string="zpt/zogiLibMain_%s.zpt"%version  
         self._default_content_fn = os.path.join(package_home(globals()),default_content_string)  
         self.id = str(id)  
         self.ZBindings_edit(self._default_bindings)  
         if text is None:  
             text = open(self._default_content_fn).read()  
         self.pt_edit(text, content_type)  
   
           
 def manage_addZogiLibMainTemplateForm(self):  def manage_addZogiLibMainTemplateForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddOSAS_thumbTemplate.zpt').__of__(self)      #FIXME:???
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/AddOSAS_thumbTemplate.zpt')).__of__(self)
     return pt()      return pt()
   
   
Line 130  def manage_addZogiLibMainTemplateForm(se Line 71  def manage_addZogiLibMainTemplateForm(se
 def manage_addZogiLibMainTemplate(self, id,title=None, text=None,  def manage_addZogiLibMainTemplate(self, id,title=None, text=None,
                            REQUEST=None, submit=None):                             REQUEST=None, submit=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
       #FIXME:???
       
     id = str(id)      id = str(id)
     if REQUEST is None:      if REQUEST is None:
         self._setObject(id, zogiLib_mainTemplate(id, text))          self._setObject(id, zogiLib_mainTemplate(id, text))
Line 167  class zogiImage(Image): Line 107  class zogiImage(Image):
     """einzelnes Image"""      """einzelnes Image"""
     meta_type="zogiImage"      meta_type="zogiImage"
   
       manage_options=ZopePageTemplate.manage_options+(
           {'label':'Main config','action':'changeZogiImageForm'},
          )
           
           
     def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):      def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
Line 184  class zogiImage(Image): Line 127  class zogiImage(Image):
   
     def changeZogiImageForm(self):      def changeZogiImageForm(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiImageForm.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):      def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):
Line 197  class zogiImage(Image): Line 140  class zogiImage(Image):
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'Main config','action':'changeZogiImageForm'},  
        )  
   
       
   
           
     def index_html(self, REQUEST, RESPONSE):      def index_html(self, REQUEST, RESPONSE):
         """          """
         Modified version of OFS/Image.py          Modified version of OFS/Image.py
Line 470  class zogiImage(Image): Line 406  class zogiImage(Image):
   
 def manage_addZogiImageForm(self):  def manage_addZogiImageForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiImage.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
     return pt()      return pt()
   
   
Line 488  class zogiLib(Folder): Line 424  class zogiLib(Folder):
   
     meta_type="zogiLib"      meta_type="zogiLib"
   
     def getDlInfo(self):      manage_options = Folder.manage_options+(
         """DLInfo"""              {'label':'Main Config','action':'changeZogiLibForm'},
               )
   
       def __init__(self, id, title, digilibBaseUrl, localFileBase, version="book", basePath=""):
           """init"""
   
           self.id=id
           self.title=title
           self.digilibBaseUrl=digilibBaseUrl
           self.localFileBase=localFileBase
           self.basePath=basePath
           self.layout=version
   
   
       def getDLInfo(self):
           """get DLInfo from digilib server"""
         paramH={}          paramH={}
         baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)          baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)
                   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)
         params=dom.getElementsByTagName('parameter')          params=dom.getElementsByTagName('parameter')
         for param in params:          for param in params:
             paramH[param.getAttribute('name')]=param.getAttribute('value')              paramH[param.getAttribute('name')]=param.getAttribute('value')
         return paramH          return paramH
   
     def getPageNumTotal(self):  
         """pagenums"""  
         return self.getDlInfo()['pt'].encode('utf-8')  
       
       
     def generateImageFolder(self):  
         """images ablegen"""  
         self.manage_addFolder('images')  
         pathName=os.path.join(package_home(globals()),'images')  
         for image in os.listdir(pathName):  
             try:  
                   
                 fn=file(os.path.join(pathName,image))  
                 self.images.manage_addImage(image,fn)  
             except:              except:
                 print "ZOGILIB not imported:",image              return null
                                   
                           
       def createHeadJS(self):
           """generate all javascript tags for head"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
           return pt()
                   
       def createParamJS(self):
           """generate javascript for parameters only"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
           return pt()
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):  
         """init"""  
   
         self.id=id      def createScalerImg(self, requestString = None, bottom = 0, side = 0):
         self.title=title          """generate Scaler IMG Tag"""
         self.digilibBaseUrl=digilibBaseUrl      self.checkQuery()
         self.localFileBase=localFileBase      bt = self.REQUEST.SESSION['browserType']
         #self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))          # override with parameters from session
         self._setObject('mainTemplate',zogiLib_mainTemplate(id='mainTemplate',version=version))          if  self.REQUEST.SESSION.has_key('scalerDiv'):
         self.generateImageFolder()              (requestString, bottom, side) = self.REQUEST.SESSION['scalerDiv']
           # if not explicitly defined take normal request
           if not requestString:
               requestString = self.getAllDLParams()
           url = self.digilibBaseUrl+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.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):
           """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)
           else:
               if self.REQUEST.SESSION.has_key('scalerDiv'):
                   del self.REQUEST.SESSION['scalerDiv']
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
           return pt()
   
       def createAuxDiv(self):
           """generate other divs"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           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()
   
     manage_options = Folder.manage_options+(  
             {'label':'Main Config','action':'changeZogiLibForm'},  
             )  
   
     def option_js(self):      def option_js(self):
         """option_js"""          """option_js"""
         ret="""function setDLParam(e) {          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/option_js')).__of__(self)
           if (document.all) {  
             s=e.srcElement;  
           } else {  
             s=e.target;  
           }  
           if (window.opener) {  
             window.opener.setParameter(s.name, s.value);  
             window.opener.display(9);  
           } else {  
             document.setParameter(s.name, s.value);  
             document.display(9);  
           }  
         }"""  
         return ret  
                           
                           
     def navigation_js(self):  
         """Javascript"""  
         fileName=os.path.join(package_home(globals()),'js/navigation.js')  
         return file(fileName).read()  
   
   
               
     def generateTopJavaScript(self):  
         """generate script"""  
         ret="""  
         var baseUrl = '%s'; """% self.REQUEST['URL0']  
         ret+="""  
         newParameter('fn', '', 1);  
         newParameter('pn', '1', 1);  
         newParameter('ws', '1.0', 1);  
         newParameter('mo', '', 1);  
         newParameter('mk', '', 3);  
         newParameter('wx', '0.0', 2);  
         newParameter('wy', '0.0', 2);  
         newParameter('ww', '1.0', 2);  
         newParameter('wh', '1.0', 2);  
         newParameter('pt', '0', 9);  
         newParameter('brgt', '0.0', 1);  
         newParameter('cont', '0.0', 1);  
         newParameter('rot', '0.0', 1);  
         newParameter('rgba', '', 1);  
         newParameter('rgbm', '', 1);  
         newParameter('ddpix', '', 9);  
         newParameter('ddpiy', '', 9);  
         var picsize = new Size(100, 100);  
         document.id='digilib';  
   
         """  
         return ret  
   
           
     def generateScalerImg(self,requestString):  
         """generate Scaler IMG Tag"""  
         retStr=self.digilibBaseUrl+requestString  
         jS="""<script type="text/javascript">picsize = bestPicSize('scaler');  
         document.write('<img id="pic" src="%s&dw='+picsize.width+'&dh='+picsize.height+'" />')  
         </script>"""%retStr  
         return jS  
   
     def changeZogiLibForm(self):  
         """Main configuration"""  
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)  
         return pt()          return pt()
           
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):      def dl_lib_js(self):
         """change it"""          """javascript"""
         self.title=title          return sendFile(self, 'js/dl_lib.js', 'text/plain')
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase      def js_lib_js(self):
           """javascript"""
         if RESPONSE is not None:          return sendFile(self, 'js/js_lib.js', 'text/plain')
             RESPONSE.redirect('manage_main')  
   
       def optionwindow(self):
           """showoptions"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
           return pt()
                           
     def nav_html(self,fileName):      def mark1(self):
         """navigations frame"""          """mark image"""
         ## currently not in use          return sendFile(self, 'images/mark1.gif', 'image/gif')
         # suche nach index.meta mit zogilib thumb info  
               def mark2(self):
         templ=readNavTemp(self.localFileBase+"/"+fileName)          """mark image"""
         if not templ:          return sendFile(self, 'images/mark2.gif', 'image/gif')
             templ=readNavTemp(self.localFileBase+"/"+fileName.split("/")[0])  
             if not templ:      def mark3(self):
                 return self.topTemplate.document_src()          """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"""
           tp = "zogiLibMainTemplate"
           if hasattr(self, tp):
           pt = getattr(self, tp)
           else:
               pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%self.layout)).__of__(self)
           return pt()
   
   
         #pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_image.zpt').__of__(self)  
         #return pt()  
         return self.mainTemplate()  
   
     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
           if more:
               for fm in more.split('&'):
                   try:
                       pv = fm.split('=')
                       dlParams[pv[0]] = pv[1]
                   except:
                       print "ouch!"
           # parse digilib mode parameter
           if 'mo' in dlParams:
               if len(dlParams['mo']) > 0:
                   modes=dlParams['mo'].split(',')
           else:
               modes=[]
   
           self.REQUEST.SESSION['query'] = dlParams
           self.REQUEST.SESSION['dlModes'] = modes
           self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()
           self.REQUEST.SESSION['browserType'] = BrowserCheck(self)
   
       def checkQuery(self):
       """check if the query has been stored"""
       if not (self.REQUEST.SESSION):
           print "ZOGILIB: have to store query!!"
           self.storeQuery
           return
   
         self.REQUEST.SESSION['dlInfo']=self.getDlInfo()      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 getParam(self,param):      def getDLParam(self, param):
         """Gebe Parameter aus"""          """returns parameter"""
         try:          try:
             return self.REQUEST.SESSION['query'][param]              return self.REQUEST.SESSION['query'][param]
         except:          except:
             return None  
   
     def getPageNum(self):  
         """PAgenum"""  
         pn=self.getParam('pn')  
         if pn:  
             return pn  
         else:  
             return 1  
   
     def biggerWS(self):  
         """ws+1"""  
         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                  return
             else:  
                 return int(ws)-1  
         else:  
             return 1  
                   
       def setDLParam(self, param, value):
           """sets parameter"""
           self.REQUEST.SESSION['query'][param] = value
           return
                   
     def setParam(self,pn=None,ws=None,rot=None,brgt=None,cont=None):      def getAllDLParams(self):
         """setze Parameter"""          """parameter string for digilib"""
           dlParams = self.REQUEST.SESSION['query']
           # save modes
           modes = self.REQUEST.SESSION['dlModes']
           dlParams['mo'] = string.join(modes, ',')
           # assemble query string
         ret=""          ret=""
           for param in dlParams.keys():
               val = str(dlParams[param])
               if val != "":
                   ret += param + "=" + val + "&"
           # omit trailing "&"
           return ret.rstrip('&')
   
         if brgt:  
             self.REQUEST.SESSION['query']['brgt']=brgt  
   
         if cont:  
             self.REQUEST.SESSION['query']['cont']=cont  
   
         if pn:      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
             self.REQUEST.SESSION['query']['pn']=pn          """setze Parameter"""
   
         if ws:  
             self.REQUEST.SESSION['query']['ws']=ws  
   
         if rot:  
             self.REQUEST.SESSION['query']['rot']=rot  
               
         for param in self.REQUEST.SESSION['query'].keys():  
               
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"  
                   
         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"""
           params = self.getAllDLParams()
           if self.basePath:
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
             else:              else:
                 splitted.append('hmir')              self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
   
         if mi=="v":  
   
             if 'vmir' in splitted:      def getPT(self):
                 splitted.remove('vmir')          """pagenums"""
           di = self.REQUEST.SESSION['dlInfo']
           if di:
               return int(di['pt'])
             else:              else:
                 splitted.append('vmir')              return 1
   
   
         self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")  
           
           
           
           
         for param in self.REQUEST.SESSION['query'].keys():  
               
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"  
           
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
           
     def decode(self,strR):  
         """decode &"""  
           
         return re.sub('\&amp','\&',strR)  
       
     def wholePage(self):  
         """zoom out"""  
         ret=""  
           
         self.REQUEST.SESSION['query']['ww']=1  
         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():  
               
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"  
           
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
           
     def prevPage(self,pn=None):  
         """next page"""  
         ret=""  
   
         if pn and pn>0:  
             pn=str(int(pn)-1)  
           
   
         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 firstPage(self):  
         """erste Seite"""  
         return self.setParam(pn="1")  
       
     def lastPage(self):  
         """letzte Seite"""  
   
       def getPN(self):
           """Pagenum"""
           pn = self.getDLParam('pn')
           try:
               return int(pn)
           except:
               return 1
                   
     def nextPage(self,pn=None):      def getBiggerWS(self):
         """next page"""          """ws+1"""
         ret=""          ws = self.getDLParam('ws')
           try:
               return int(ws)+1
           except:
               return 2
                   
       def getSmallerWS(self):
           """ws-1"""
           ws=self.getDLParam('ws')
         try:          try:
             pn=str(int(pn)+1)              return max(int(ws)-1, 1)
         except:          except:
             pn=str(2)              return 1
   
         self.REQUEST.form['pn']=pn      def hasMode(self, mode):
           """returns if mode is in the diglib mo parameter"""
           return (mode in self.REQUEST.SESSION['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_HMirror(self):
           """mirror action"""
           modes = self.REQUEST.SESSION['dlModes']
           if 'hmir' in modes:
               modes.remove('hmir')
           else:
               modes.append('hmir')
   
           return self.display()
          
       def dl_VMirror(self):
           """mirror action"""
           modes = self.REQUEST.SESSION['dlModes']
           if 'vmir' in modes:
               modes.remove('vmir')
           else:
               modes.append('vmir')
   
           return self.display()
   
       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', ww2)
           self.setDLParam('wh', wh2)
           self.setDLParam('wx', wx)
           self.setDLParam('wy', 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', wx)
           self.setDLParam('wy', 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()
                   
         for param in self.REQUEST.form.keys():  
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
   
     def generateDivs(self):      def changeZogiLibForm(self):
         """generate divs"""          """Main configuration"""
         pt=PageTemplateFile('Products/zogiLib/zpt/zogilib_divs').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
         return pt()          return pt()
   
         #divFileName=os.path.join(package_home(globals()),'zpt/zogilib_divs.zpt')      def changeZogiLib(self,title,digilibBaseUrl, localFileBase, version, basePath, RESPONSE=None):
         #return open(divFileName).read()          """change it"""
           self.title=title
           self.digilibBaseUrl=digilibBaseUrl
           self.localFileBase=localFileBase
           self.basePath = basePath
           self.layout=version
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
                       
 def manage_addZogiLibForm(self):  def manage_addZogiLibForm(self):
     """interface for adding zogilib"""      """interface for adding zogilib"""
     pt=PageTemplateFile('Products/zogiLib/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",RESPONSE=None):  def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",basePath="",RESPONSE=None):
     """add dgilib"""      """add dgilib"""
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version)      newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version, basePath)
     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')
Removed from v.1.9  
changed lines
  Added in v.1.25

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