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

Diff for /zogiLib/zogiLib.py between versions 1.17 and 1.18

version 1.17, 2004/05/18 17:54:34 version 1.18, 2004/06/02 17:32:54
Line 32  def sendFile(self, filename, type): Line 32  def sendFile(self, filename, type):
         object = None          object = None
         break          break
     if object:      if object:
     # send the object      # if the object exists then send it
     object()      return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
     else:      else:
     # send a local file with the given content-type      # send a local file with the given content-type
     fn = os.path.join(package_home(globals()), filename)      fn = os.path.join(package_home(globals()), filename)
Line 41  def sendFile(self, filename, type): Line 41  def sendFile(self, filename, type):
     self.REQUEST.RESPONSE.write(file(fn).read())      self.REQUEST.RESPONSE.write(file(fn).read())
     return      return
   
 class zogiLib_navTemplate(ZopePageTemplate):  class BrowserCheck:
     """pageTemplate Objekt"""      """check the browsers request to find out the browser type"""
     meta_type="zogiLib_navTemplate"  
   
     _default_content_fn = os.path.join(package_home(globals()),      def __init__(self, zope):
                                        'zpt/zogiLib_NavTemplateDefault.zpt')      self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
       self.isIE = string.find(self.ua, 'MSIE') > -1
     manage_options=ZopePageTemplate.manage_options+(      self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and not self.isIE
         {'label':'Copy to Filesystem','action':'copyContent'},      self.nav = self.ua[string.find(self.ua, '('):]
        )      ie = string.split(self.nav, "; ")[1]
       if string.find(ie, "MSIE") > -1:
     def getPath(self):          self.versIE = string.split(ie, " ")[1]
         """get path"""      self.isMac = string.find(self.ua, 'Macintosh') > -1
         return getPath(self,'thumbtemplate.templ')      self.isWin = string.find(self.ua, 'Windows') > -1
           self.isIEWin = self.isIE and self.isWin
       self.isIEMac = self.isIE and self.isMac
     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:  
         return None  
       
       
     try:  
         navTag=getText(dom.getElementsByTagName('zogilibtemplate')[0].childNodes)  
     except:  
         navTag=None  
     return navTag  
   
 class zogiLib_mainTemplate(ZopePageTemplate):  
     """pageTemplate Objekt"""  
     meta_type="zogiLib_mainTemplate"  
   
       
     def __init__(self, id, text=None, content_type=None, version="book"):  
   
         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 151  def manage_addZogiLibMainTemplateForm(se Line 70  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 188  class zogiImage(Image): Line 106  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 205  class zogiImage(Image): Line 126  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 218  class zogiImage(Image): Line 139  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 491  class zogiImage(Image): Line 405  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 509  class zogiLib(Folder): Line 423  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"):
           """init"""
   
           self.id=id
           self.title=title
           self.digilibBaseUrl=digilibBaseUrl
           self.localFileBase=localFileBase
           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 __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):  
         """init"""  
   
         self.id=id      def createHeadJS(self):
         self.title=title          """generate javascript tags for head"""
         self.digilibBaseUrl=digilibBaseUrl          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
         self.localFileBase=localFileBase          return pt()
         #self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))  
         self._setObject('mainTemplate',zogiLib_mainTemplate(id='mainTemplate',version=version))  
         #self.generateImageFolder()  
   
       def createScalerImg(self, requestString = None):
           """generate Scaler IMG Tag"""
           bt = self.REQUEST.SESSION['browserType']
           if not requestString:
               requestString = self.REQUEST.QUERY_STRING
           url = self.digilibBaseUrl+requestString
           tag = ""
           if bt.isN4:
               tag += '<ilayer id="scaler">'
           else:
               tag += '<div id="scaler">'
           tag += '<script type="text/javascript">'
           tag += "var ps = bestPicSize(getElement('scaler'));"
           tag += 'document.write(\'<img id="pic" src="%s&dw=\'+ps.width+\'&dh=\'+ps.height+\'" />\')'%url
           tag += '</script>'
           if bt.isN4:
               tag += '</ilayer>'
           else:
               tag += '</div>'
           return tag
   
       def createAuxDiv(self):
           """generate other divs"""
           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="""          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/option_js')).__of__(self)
           function setDLParam(e) {          return pt()
           var s;  
           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 {  
             setParameter(s.name, s.value);  
             display(9);  
           }  
         }"""  
         return ret  
                           
                           
     def navigation_js(self):  
         """Javascript"""  
         fileName = os.path.join(package_home(globals()),'js/js_lib.js')  
         js = file(fileName).read()  
         fileName = os.path.join(package_home(globals()),'js/dl_lib.js')  
         js += file(fileName).read()  
         return js   
   
   
               
     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):      def dl_lib_js(self):
         """generate Scaler IMG Tag"""          """javascript"""
         retStr=self.digilibBaseUrl+requestString          return sendFile(self, 'js/dl_lib.js', 'text/plain')
         jS="""<script type="text/javascript">var ps = bestPicSize('scaler');  
         document.write('<img id="pic" src="%s&dw='+ps.width+'&dh='+ps.height+'" />')      def js_lib_js(self):
         </script>"""%retStr          """javascript"""
         return jS          return sendFile(self, 'js/js_lib.js', 'text/plain')
   
       def optionwindow(self):
           """showoptions"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
           return pt()
   
     def mark1(self):      def mark1(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark1.gif', 'image/gif')          return sendFile(self, 'images/mark1.gif', 'image/gif')
         return  
   
     def mark2(self):      def mark2(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark2.gif', 'image/gif')          return sendFile(self, 'images/mark2.gif', 'image/gif')
         return  
   
     def mark3(self):      def mark3(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark3.gif', 'image/gif')          return sendFile(self, 'images/mark3.gif', 'image/gif')
         return  
   
     def mark4(self):      def mark4(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark4.gif', 'image/gif')          return sendFile(self, 'images/mark4.gif', 'image/gif')
         return  
   
     def mark5(self):      def mark5(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark5.gif', 'image/gif')          return sendFile(self, 'images/mark5.gif', 'image/gif')
         return  
   
     def mark6(self):      def mark6(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark6.gif', 'image/gif')          return sendFile(self, 'images/mark6.gif', 'image/gif')
         return  
   
     def mark7(self):      def mark7(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark7.gif', 'image/gif')          return sendFile(self, 'images/mark7.gif', 'image/gif')
         return  
   
     def mark8(self):      def mark8(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/mark8.gif', 'image/gif')          return sendFile(self, 'images/mark8.gif', 'image/gif')
         return  
   
     def corner1(self):      def corner1(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/olinks.gif', 'image/gif')          return sendFile(self, 'images/olinks.gif', 'image/gif')
         return  
   
     def corner2(self):      def corner2(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/orechts.gif', 'image/gif')          return sendFile(self, 'images/orechts.gif', 'image/gif')
         return file(fileName).read()  
   
     def corner3(self):      def corner3(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/ulinks.gif', 'image/gif')          return sendFile(self, 'images/ulinks.gif', 'image/gif')
         return file(fileName).read()  
   
     def corner4(self):      def corner4(self):
         """mark image"""          """mark image"""
         sendFile(self, 'images/urechts.gif', 'image/gif')          return sendFile(self, 'images/urechts.gif', 'image/gif')
         return file(fileName).read()  
   
   
   
     def changeZogiLibForm(self):  
         """Main configuration"""  
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)  
         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:  
             RESPONSE.redirect('manage_main')  
   
               
     def nav_html(self,fileName):  
         """navigations frame"""  
         ## currently not in use  
         # suche nach index.meta mit zogilib thumb info  
           
         templ=readNavTemp(self.localFileBase+"/"+fileName)  
         if not templ:  
             templ=readNavTemp(self.localFileBase+"/"+fileName.split("/")[0])  
             if not templ:  
                 return self.topTemplate.document_src()  
   
         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):
         """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]
   
         self.REQUEST.SESSION['dlInfo']=self.getDlInfo()          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 getParam(self,param):          
         """Gebe Parameter aus"""      def getDLParam(self,param):
           """returns parameter"""
         try:          try:
             return self.REQUEST.SESSION['query'][param]              return self.REQUEST.SESSION['query'][param]
         except:          except:
             return None              return None
   
     def getPageNum(self):      def setDLParam(self, param, value):
         """PAgenum"""          """sets parameter"""
         pn=self.getParam('pn')          self.REQUEST.SESSION['query'][param] = value
         if pn:          return
             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):      def getAllDLParams(self):
         """ws-11"""          """parameter string for digilib"""
         ws=self.getParam('ws')          dlParams = self.REQUEST.SESSION['query']
         if ws:          # save modes
             if int(ws)==1:          modes = self.REQUEST.SESSION['dlModes']
                 return 1          dlParams['mo'] = string.join(modes, ',')
             else:          # assemble query string
                 return int(ws)-1          ret = ""
         else:          for param in dlParams.keys():
             return 1              val = str(dlParams[param])
               if val != "":
                   ret += param + "=" + val + "&"
           # omit trailing "&"
           return ret.rstrip('&')
                   
                   
     def setParam(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=""          ret=""
   
         if brgt:          if brgt:
             self.REQUEST.SESSION['query']['brgt']=brgt              self.setDLParam('brgt', brgt)
   
         if cont:          if cont:
             self.REQUEST.SESSION['query']['cont']=cont              self.setDLParam('cont', cont)
   
         if pn:          if pn:
             self.REQUEST.SESSION['query']['pn']=pn              self.setDLParam('pn', pn)
   
         if ws:          if ws:
             self.REQUEST.SESSION['query']['ws']=ws              self.setDLParam('ws', ws)
   
         if rot:          if rot:
             self.REQUEST.SESSION['query']['rot']=rot              self.setDLParam('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)  
   
           return self.display()
         
     def mirrorPage(self,mi):  
         """mirror"""  
         ret=""  
         try:  
             splitted=self.REQUEST.SESSION['query']['mo'].split(',')  
         except:  
             splitted=[]  
                   
         if mi=="h":      def display(self):
           """(re)display page"""
           params = self.getAllDLParams()
           self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
                                           
             if 'hmir' in splitted:      def getPT(self):
                 splitted.remove('hmir')          """pagenums"""
           di = self.REQUEST.SESSION['dlInfo']
           if di:
               return int(di['pt'])
             else:              else:
                 splitted.append('hmir')              return 1
   
         if mi=="v":  
   
             if 'vmir' in splitted:      def getPN(self):
                 splitted.remove('vmir')          """Pagenum"""
           pn = self.getDLParam('pn')
           if pn:
               return int(pn)
             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):      def getBiggerWS(self):
         """erste Seite"""          """ws+1"""
         return self.setParam(pn="1")          ws=self.getDLParam('ws')
           if ws:
               return int(ws)+1
           else:
               return 2
           
     def lastPage(self):  
         """letzte Seite"""  
   
       def getSmallerWS(self):
           """ws-1"""
           ws=self.getDLParam('ws')
           if ws:
               if int(ws)==1:
                   return 1
               else:
                   return int(ws)-1
           else:
               return 1
                   
     def nextPage(self,pn=None):      def hasMode(self, mode):
         """next page"""          """returns if mode is in the diglib mo parameter"""
         ret=""          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 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_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()
                   
         try:  
             pn=str(int(pn)+1)  
         except:  
             pn=str(2)  
   
         self.REQUEST.form['pn']=pn  
                   
         for param in self.REQUEST.form.keys():      def changeZogiLibForm(self):
             ret+=param+"="+str(self.REQUEST.form[param])+"&"          """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,digilibBaseUrl, localFileBase, version, RESPONSE=None):
           """change it"""
           self.title=title
           self.digilibBaseUrl=digilibBaseUrl
           self.localFileBase=localFileBase
           self.layout=version
   
     def generateDivs(self):          if RESPONSE is not None:
         """generate divs"""              RESPONSE.redirect('manage_main')
         pt=PageTemplateFile('Products/zogiLib/zpt/zogilib_divs').__of__(self)  
         return pt()  
   
         #divFileName=os.path.join(package_home(globals()),'zpt/zogilib_divs.zpt')  
         #return open(divFileName).read()  
                       
 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",RESPONSE=None):
Removed from v.1.17  
changed lines
  Added in v.1.18

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