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

Diff for /zogiLib/zogiLib.py between versions 1.7 and 1.31

version 1.7, 2004/04/16 14:07:08 version 1.31, 2004/07/16 13:47:50
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=''):  ZOGIVERSION = "0.9.5 ROC:25.6.2004"
     try:  
         return self.REQUEST[key]  
     except:  
         return default  
   
       
 class zogiLib_navTemplate(ZopePageTemplate):  
     """pageTemplate Objekt"""  
     meta_type="zogiLib_navTemplate"  
   
     _default_content_fn = os.path.join(package_home(globals()),  
                                        'zpt/zogiLib_NavTemplateDefault.zpt')  
   
     manage_options=ZopePageTemplate.manage_options+(  
         {'label':'Copy to Filesystem','action':'copyContent'},  
        )  
   
     def getPath(self):  
         """get path"""  
         return getPath(self,'thumbtemplate.templ')  
       
     ## def changeECHO_pageTemplateWeightForm(self):  
 ##         """change"""  
 ##         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self)  
 ##         return pt()  
   
 ##     def changeECHO_pageTemplateWeight(self,weight,content_type,RESPONSE=None):  
 ##         """change"""  
 ##         self.weight=weight  
 ##         self.content_type=content_type  
   
 ##         if RESPONSE is not None:  
 ##             RESPONSE.redirect('manage_main')  
           
   
     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):  
     """Form for adding"""  
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddOSAS_thumbTemplate.zpt').__of__(self)  
     return pt()  
   
   
   
   
 def manage_addZogiLibMainTemplate(self, id,title=None, text=None,  
                            REQUEST=None, submit=None):  
     "Add a Page Template with optional file content."  
   
   def cropf(f):
       """returns a float with reduced precision"""
       return float(int(f * 10000)/10000.0)
           
     id = str(id)  
     if REQUEST is None:  
         self._setObject(id, zogiLib_mainTemplate(id, text))  
         ob = getattr(self, id)  
                 
         if title:  def sendFile(self, filename, type):
             ob.pt_setTitle(title)      """sends an object or a local file (in the product) as response"""
         return ob      paths = filename.split('/')
       object = self
       # look for an object called filename
       for path in paths:
           if hasattr(object, path):
           object = getattr(object, path)
     else:      else:
         file = REQUEST.form.get('file')          object = None
         headers = getattr(file, 'headers', None)          break
         if headers is None or not file.filename:      if object:
             zpt = zogiLib_mainTemplate(id)      # if the object exists then send it
       return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
         else:          else:
             zpt = zogiLib_mainTemplate(id, file, headers.get('content_type'))      # send a local file with the given content-type
       fn = os.path.join(package_home(globals()), filename)
         self._setObject(id, zpt)      self.REQUEST.RESPONSE.setHeader("Content-Type", type)
         ob = getattr(self, id)      self.REQUEST.RESPONSE.write(file(fn).read())
       return
   
         try:  def browserCheck(self):
             u = self.DestinationURL()      """check the browsers request to find out the browser type"""
         except AttributeError:      bt = {}
             u = REQUEST['URL1']      ua = self.REQUEST.get_header("HTTP_USER_AGENT")
       bt['ua'] = ua
       bt['isIE'] = string.find(ua, 'MSIE') > -1
       bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1) and not bt['isIE']
       nav = ua[string.find(ua, '('):]
       ie = string.split(nav, "; ")[1]
       if string.find(ie, "MSIE") > -1:
           bt['versIE'] = string.split(ie, " ")[1]
       bt['isMac'] = string.find(ua, 'Macintosh') > -1
       bt['isWin'] = string.find(ua, 'Windows') > -1
       bt['isIEWin'] = bt['isIE'] and bt['isWin']
       bt['isIEMac'] = bt['isIE'] and bt['isMac']
       bt['staticHTML'] = False
   
         if submit == " Add and Edit ":      return bt
             u = "%s/%s" % (u, quote(id))  
         REQUEST.RESPONSE.redirect(u+'/manage_main')  
     return ''  
   
           
 class zogiImage(Image):  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 197  class zogiImage(Image): Line 87  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 210  class zogiImage(Image): Line 100  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 483  class zogiImage(Image): Line 366  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 501  class zogiLib(Folder): Line 384  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="", dlTarget=None):
           """init"""
   
           self.id=id
           self.title=title
           self.digilibBaseUrl=digilibBaseUrl
           self.localFileBase=localFileBase
           self.basePath=basePath
           self.layout=version
           if dlTarget:
               self.dlTarget = dlTarget
           else:
               self.dlTarget = "digilib"
   
       def version(self):
           """version information"""
           return ZOGIVERSION
   
       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
           except:
               return null
   
     def getPageNumTotal(self):  
         """pagenums"""  
         return self.getDlInfo()['pt']  
           
       def createHeadJS(self):
           """generate all javascript tags for head"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
           
     def generateImageFolder(self):          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
         """images ablegen"""          return pt()
         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))      def createParamJS(self):
                 self.images.manage_addImage(image,fn)          """generate javascript for parameters only"""
             except:      self.checkQuery()
                 print "ZOGILIB not imported:",image      bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
                                   
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
           return pt()
                           
                   
       def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
           """generate Scaler IMG Tag"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           # override with parameters from session
           if  self.REQUEST.SESSION.has_key('scalerDiv'):
               (requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']
           # if not explicitly defined take normal request
           if not requestString:
               requestString = self.getAllDLParams()
           url = self.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['staticHTML']:
               tag += '<div id="scaler"><img id="pic" src="%s&dw=%i&dh=%i" /></div>'%(url, int(width-side), int(height-bottom))
           else:
               if bt['isN4']:
                   # N4 needs layers
                   tag += '<ilayer id="scaler">'
               else:
                   tag += '<div id="scaler">'
               tag += '<script type="text/javascript">'
               tag += "var ps = bestPicSize(getElement('scaler'));"
               # write img tag with javascript
               tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\');'%(url, s_par, b_par)
               tag += '</script>'
               if bt['isN4']:
                   tag += '</ilayer>'
               else:
                   tag += '</div>'
           return tag
   
     def __init__(self, id,title,digilibBaseUrl, localFileBase,version="book"):      def createScalerDiv(self, requestString = None, bottom = 0, side = 0, width=500, height=500):
         """init"""          """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']
   
         self.id=id          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
         self.title=title          return pt()
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase  
         #self._setObject('topTemplate',zogiLib_navTemplate(id='topTemplate'))  
         self._setObject('mainTemplate',zogiLib_mainTemplate(id='mainTemplate',version=version))  
         self.generateImageFolder()  
   
       def createAuxDiv(self):
           """generate other divs"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           if bt['staticHTML']:
               return
           if bt['isN4']:
               f = 'zpt/zogilib_divsN4.zpt'
           else:
               f = 'zpt/zogilib_divs.zpt'
           pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self)
           return pt()
   
     manage_options = Folder.manage_options+(  
             {'label':'Main Config','action':'changeZogiLibForm'},  
             )  
   
     def option_js(self):      def option_js(self):
         """option_js"""          """javascript"""
         ret="""function setDLParam(e) {          return sendFile(self, 'js/option.js', 'text/plain')
           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 dl_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/dl_lib.js', 'text/plain')
   
       def js_lib_js(self):
           """javascript"""
           return sendFile(self, 'js/js_lib.js', 'text/plain')
                   
     def generateScalerImg(self,requestString):      def optionwindow(self):
         """generate Scaler IMG Tag"""          """showoptions"""
         retStr=self.digilibBaseUrl+requestString      self.checkQuery()
         jS="""<script type="text/javascript">picsize = bestPicSize('scaler');      bt = self.REQUEST.SESSION['browserType']
         document.write('<img id="pic" src="%s&dw='+picsize.width+'&dh='+picsize.height+'" />')          if bt['staticHTML']:
         </script>"""%retStr              pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
         return jS          else:
           finds=self.ZopeFind(self,obj_ids=['viewingTools.zpt'])
           if finds:
   
     def changeZogiLibForm(self):          return finds[0][1]()
         """Main configuration"""          else:
         pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiLibForm.zpt').__of__(self)                  pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
         return pt()          return pt()
           
     def changeZogiLib(self,title,digilibBaseUrl, localFileBase,RESPONSE=None):      def mark1(self):
         """change it"""          """mark image"""
         self.title=title          return sendFile(self, 'images/mark1.gif', 'image/gif')
         self.digilibBaseUrl=digilibBaseUrl  
         self.localFileBase=localFileBase      def mark2(self):
           """mark image"""
         if RESPONSE is not None:          return sendFile(self, 'images/mark2.gif', 'image/gif')
             RESPONSE.redirect('manage_main')  
       def mark3(self):
                       """mark image"""
     def nav_html(self,fileName):          return sendFile(self, 'images/mark3.gif', 'image/gif')
         """navigations frame"""  
         ## currently not in use      def mark4(self):
         # suche nach index.meta mit zogilib thumb info          """mark image"""
                   return sendFile(self, 'images/mark4.gif', 'image/gif')
         templ=readNavTemp(self.localFileBase+"/"+fileName)  
         if not templ:      def mark5(self):
             templ=readNavTemp(self.localFileBase+"/"+fileName.split("/")[0])          """mark image"""
             if not templ:          return sendFile(self, 'images/mark5.gif', 'image/gif')
                 return self.topTemplate.document_src()  
       def mark6(self):
           """mark image"""
           return sendFile(self, 'images/mark6.gif', 'image/gif')
   
       def mark7(self):
           """mark image"""
           return sendFile(self, 'images/mark7.gif', 'image/gif')
   
       def mark8(self):
           """mark image"""
           return sendFile(self, 'images/mark8.gif', 'image/gif')
   
       def corner1(self):
           """mark image"""
           return sendFile(self, 'images/olinks.gif', 'image/gif')
   
       def corner2(self):
           """mark image"""
           return sendFile(self, 'images/orechts.gif', 'image/gif')
   
       def corner3(self):
           """mark image"""
           return sendFile(self, 'images/ulinks.gif', 'image/gif')
   
       def corner4(self):
           """mark image"""
           return sendFile(self, 'images/urechts.gif', 'image/gif')
   
       def up_img(self):
           """mark image"""
           return sendFile(self, 'images/up.gif', 'image/gif')
   
       def down_img(self):
           """mark image"""
           return sendFile(self, 'images/down.gif', 'image/gif')
   
       def left_img(self):
           """mark image"""
           return sendFile(self, 'images/left.gif', 'image/gif')
   
       def right_img(self):
           """mark image"""
           return sendFile(self, 'images/right.gif', 'image/gif')
   
         return urllib.urlopen(templ).read()  
           
           
     def index_html(self):      def index_html(self):
         """main action"""          """main action"""
       self.checkQuery()
       bt = self.REQUEST.SESSION['browserType']
           tp = "zogiLibMainTemplate"
           if hasattr(self, tp):
           pt = getattr(self, tp)
           else:
               tpt = self.layout
               if bt['staticHTML']:
                   tpt = "static"
   
               pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)
   
         #pt=PageTemplateFile('Products/zogiLib/zpt/zogiLibMain_image.zpt').__of__(self)          return pt()
         #return pt()  
         return self.mainTemplate()  
   
     def storeQuery(self):  
         """storeQuery in session"""  
         self.REQUEST.SESSION['query']={}  
         for fm in self.REQUEST.form.keys():  
             self.REQUEST.SESSION['query'][fm]=self.REQUEST.form[fm]  
   
         self.REQUEST.SESSION['dlInfo']=self.getDlInfo()  
                   
     def getParam(self,param):      def storeQuery(self, more = None):
         """Gebe Parameter aus"""          """storeQuery in session"""
           dlParams = {}
           for fm in self.REQUEST.form.keys():
               dlParams[fm] = self.REQUEST.form[fm]
           # look for more
           if more:
               for fm in more.split('&'):
         try:          try:
             return self.REQUEST.SESSION['query'][param]                      pv = fm.split('=')
                       dlParams[pv[0]] = pv[1]
         except:          except:
             return None                      pass
   
     def getPageNum(self):  
         """PAgenum"""  
         pn=self.getParam('pn')  
         if pn:  
             return pn  
         else:  
             return 1  
   
     def biggerWS(self):          # parse digilib mode parameter
         """ws+1"""          if 'mo' in dlParams:
         ws=self.getParam('ws')              if len(dlParams['mo']) > 0:
         if ws:                  modes=dlParams['mo'].split(',')
             return int(ws)+1  
         else:          else:
             return 2              modes=[]
   
     def options(self):          self.REQUEST.SESSION['query'] = dlParams
         """showoptions"""          self.REQUEST.SESSION['dlModes'] = modes
         pt=PageTemplateFile('Products/zogiLib/zpt/optionwindow.zpt').__of__(self)          self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()
         return pt()          if not self.REQUEST.SESSION.has_key('browserType'):
               self.REQUEST.SESSION['browserType'] = browserCheck(self)
   
           return
                   
     def smallerWS(self):      def checkQuery(self):
         """ws-11"""      """check if the query has been stored"""
         ws=self.getParam('ws')      if not (self.REQUEST.SESSION and self.REQUEST.SESSION.has_key('query')) :
         if ws:          print "ZOGILIB: have to store query!!"
             if int(ws)==1:          self.storeQuery()
                 return                  return
   
       def zogilibPath(self, otherbase=None):
           """returns an URL to the zogiLib instance"""
           url = self.REQUEST['URL1']
           # should end with "/"
           if len(url) > 0 and url[-1] != '/':
               url += '/'
           if type(otherbase) is str:
               url += otherbase
             else:              else:
                 return int(ws)-1              url += self.basePath
         else:          # should end with "/"
             return 1          if len(url) > 0 and url[-1] != '/':
               url += '/'
           return url
           
       def getDLParam(self, param):
           """returns parameter"""
           try:
               return self.REQUEST.SESSION['query'][param]
           except:
               return
                   
       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():
               if dlParams[param] is None: continue
               val = str(dlParams[param])
               if val != "":
                   ret += param + "=" + val + "&"
   
           # omit trailing "&"
           return ret.rstrip('&')
   
         if brgt:  
             self.REQUEST.SESSION['query']['brgt']=brgt  
   
         if cont:      def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
             self.REQUEST.SESSION['query']['cont']=cont          """setze Parameter"""
   
           self.setDLParam('brgt', brgt)
           self.setDLParam('cont', cont)
           self.setDLParam('ws', ws)
           self.setDLParam('rot', rot)
   
         if pn:          if pn:
             self.REQUEST.SESSION['query']['pn']=pn              # unmark
               self.setDLParam('mk', None)
               self.setDLParam('pn', pn)
               
           return self.display()
   
         if ws:  
             self.REQUEST.SESSION['query']['ws']=ws  
   
         if rot:      def display(self):
             self.REQUEST.SESSION['query']['rot']=rot          """(re)display page"""
           params = self.getAllDLParams()
           if self.basePath:
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
           else:
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)
                           
         for param in self.REQUEST.SESSION['query'].keys():  
                           
             ret+=param+"="+str(self.REQUEST.SESSION['query'][param])+"&"      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
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)      def isStaticHTML(self):
           """returns if the page is using static HTML only"""
           self.checkQuery()
       return self.REQUEST.SESSION['browserType']['staticHTML']
   
       def getPT(self):
           """pagenums"""
           di = self.REQUEST.SESSION['dlInfo']
           if di:
               return int(di['pt'])
           else:
               return 1
         
     def mirrorPage(self,mi):      def getPN(self):
         """mirror"""          """Pagenum"""
         ret=""          pn = self.getDLParam('pn')
         try:          try:
             splitted=self.REQUEST.SESSION['query']['mo'].split(',')              return int(pn)
         except:          except:
             splitted=[]              return 1
           
         if mi=="h":  
                                           
             if 'hmir' in splitted:      def getBiggerWS(self):
                 splitted.remove('hmir')          """ws+1"""
             else:          ws = self.getDLParam('ws')
                 splitted.append('hmir')          try:
               return float(ws)+0.5
           except:
               return 1.5
   
         if mi=="v":      def getSmallerWS(self):
           """ws-1"""
           ws=self.getDLParam('ws')
           try:
               return max(float(ws)-0.5, 1)
           except:
               return 1
   
             if 'vmir' in splitted:      def hasMode(self, mode):
                 splitted.remove('vmir')          """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_StaticHTML(self):
           """set rendering to static HTML"""
           self.checkQuery()
           self.REQUEST.SESSION['browserType']['staticHTML'] = True
           return self.display()
   
       def dl_DynamicHTML(self):
           """set rendering to dynamic HTML"""
           self.checkQuery()
           self.REQUEST.SESSION['browserType']['staticHTML'] = False
           return self.display()
           
       def dl_HMirror(self):
           """mirror action"""
           modes = self.REQUEST.SESSION['dlModes']
           if 'hmir' in modes:
               modes.remove('hmir')
             else:              else:
                 splitted.append('vmir')              modes.append('hmir')
   
   
         self.REQUEST.SESSION['query']['mo']=string.join(splitted,",")          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', cropf(ww2))
           self.setDLParam('wh', cropf(wh2))
           self.setDLParam('wx', cropf(wx))
           self.setDLParam('wy', cropf(wy))
           return self.display()
           
       def dl_ZoomIn(self):
           """zoom in action"""
           z = 0.7071
           return self.dl_Zoom(z)
   
       def dl_ZoomOut(self):
           """zoom out action"""
           z = 1.4142
           return self.dl_Zoom(z)
   
       def dl_Move(self, dx, dy):
           """general move action"""
           ww = float(self.getDLParam('ww') or 1)
           wh = float(self.getDLParam('wh') or 1)
           wx = float(self.getDLParam('wx') or 0)
           wy = float(self.getDLParam('wy') or 0)
           wx += dx * 0.5 * ww
           wy += dy * 0.5 * wh
           wx = max(min(wx, 1), 0)
           wy = max(min(wy, 1), 0)
           self.setDLParam('wx', cropf(wx))
           self.setDLParam('wy', cropf(wy))
           return self.display()
           
       def dl_MoveLeft(self):
           """move left action"""
           return self.dl_Move(-1, 0)
       
       def dl_MoveRight(self):
           """move left action"""
           return self.dl_Move(1, 0)
       
       def dl_MoveUp(self):
           """move left action"""
           return self.dl_Move(0, -1)
       
       def dl_MoveDown(self):
           """move left action"""
           return self.dl_Move(0, 1)
       
       def dl_WholePage(self):
           """zoom out action"""
           self.setDLParam('ww', 1)
           self.setDLParam('wh', 1)
           self.setDLParam('wx', 0)
           self.setDLParam('wy', 0)
           return self.display()
           
       def dl_PrevPage(self):
           """next page action"""
           pn = self.getPN() - 1
           if pn < 1:
               pn = 1
           self.setDLParam('pn', pn)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
           
       def dl_NextPage(self):
           """next page action"""
           pn = self.getPN() + 1
           pt = self.getPT()
           if pn > pt:
               pn = pt
           self.setDLParam('pn', pn)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
   
       def dl_FirstPage(self):
           """first page action"""
           self.setDLParam('pn', 1)
           # unmark
           self.setDLParam('mk', None)
           return self.display()
       
       def dl_LastPage(self):
           """last page action"""
           self.setDLParam('pn', self.getPT())
           # unmark
           self.setDLParam('mk', None)
           return self.display()
   
       def dl_Unmark(self):
           """action to remove last mark"""
           mk = self.getDLParam('mk')
           if mk:
               marks = mk.split(',')
               marks.pop()
               mk = string.join(marks, ',')
               self.setDLParam('mk', mk)
           return self.display()
                   
         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 changeZogiLibForm(self):
           """Main configuration"""
           pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
           return pt()
                   
     def prevPage(self,pn=None):      def changeZogiLib(self,title,digilibBaseUrl, localFileBase, version, basePath, dlTarget, RESPONSE=None):
         """next page"""          """change it"""
         ret=""          self.title=title
           self.digilibBaseUrl=digilibBaseUrl
           self.localFileBase=localFileBase
           self.basePath = basePath
           self.layout=version
           if dlTarget:
               self.dlTarget = dlTarget
           else:
               self.dlTarget = "digilib"
   
         if pn and pn>0:          if RESPONSE is not None:
             pn=str(int(pn)-1)              RESPONSE.redirect('manage_main')
                   
   
         self.REQUEST.form['pn']=pn  def manage_addZogiLibForm(self):
       """interface for adding zogilib"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
       return pt()
                   
         for param in self.REQUEST.form.keys():  def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",basePath="",dlTarget="digilib",RESPONSE=None):
       """add dgilib"""
       newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version, basePath, dlTarget)
       self.Destination()._setObject(id,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
                           
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
                   
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  class zogiLibPageTemplate(ZopePageTemplate):
       """pageTemplate Objekt"""
       meta_type="zogiLib_pageTemplate"
   
     def firstPage(self):  
         """erste Seite"""  
         return self.setParam(pn="1")  
           
     def lastPage(self):  ## def __init__(self, id, text=None, contentType=None):
         """letzte Seite"""  ##         self.id = str(id)
   ##         self.ZBindings_edit(self._default_bindings)
   ##         if text is None:
   ##             text = open(self._default_cont).read()
   ##         self.pt_edit(text, contentType)
   
   def manage_addZogiLibPageTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
       return pt()
                   
     def nextPage(self,pn=None):  def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,
         """next page"""                             REQUEST=None, submit=None):
         ret=""      "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:          try:
             pn=str(int(pn)+1)          u = self.DestinationURL()
         except:      except AttributeError:
             pn=str(2)          u = REQUEST['URL1']
   
         self.REQUEST.form['pn']=pn  
           
         for param in self.REQUEST.form.keys():  
             ret+=param+"="+str(self.REQUEST.form[param])+"&"  
           
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+ret)  
   
           
 def manage_addZogiLibForm(self):  
     """interface for adding zogilib"""  
     pt=PageTemplateFile('Products/zogiLib/zpt/addZogiLibForm').__of__(self)  
     return pt()  
   
 def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",RESPONSE=None):      u = "%s/%s" % (u, urllib.quote(id))
     """add dgilib"""      REQUEST.RESPONSE.redirect(u+'/manage_main')
     newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version)      return ''
     self.Destination()._setObject(id,newObj)  
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
Removed from v.1.7  
changed lines
  Added in v.1.31

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