Return to zogiLib.py CVS log

Up to [Repository] / zogiLib

minor

from OFS.SimpleItem import SimpleItem
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from OFS.Image import Image
from AccessControl import ClassSecurityInfo
import xml.dom.minidom
from OFS.Folder import Folder
from xml_helpers import getUniqueElementText,getText
import os
import re
import string
import urllib
from types import *
import random
import cgi
from Globals import package_home

ZOGIVERSION = "0.9.15b DW:22.2.2005"

def cropf(f):
    """returns a float with reduced precision"""
    return float(int(f * 10000)/10000.0)


def sendFile(self, filename, type):
    """sends an object or a local file (from the product) as response"""
    paths = filename.split('/')
    object = self
    # look for an object called filename
    for path in paths:
        if hasattr(object, path):
	    object = getattr(object, path)
	else:
	    object = None
	    break
    if object:
	# if the object exists then send it
	return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
    else:
	# send a local file with the given content-type
	fn = os.path.join(package_home(globals()), filename)
	self.REQUEST.RESPONSE.setHeader("Content-Type", type)
	self.REQUEST.RESPONSE.write(file(fn).read())
    return

def browserCheck(self):
    """check the browsers request to find out the browser type"""
    bt = {}
    ua = self.REQUEST.get_header("HTTP_USER_AGENT")
    bt['ua'] = ua
    bt['isIE'] = False
    bt['isN4'] = False
    if string.find(ua, 'MSIE') > -1:
        bt['isIE'] = True
    else:
        bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
        
    try:
        nav = ua[string.find(ua, '('):]
        ie = string.split(nav, "; ")[1]
        if string.find(ie, "MSIE") > -1:
            bt['versIE'] = string.split(ie, " ")[1]
    except: pass
    
    bt['isMac'] = string.find(ua, 'Macintosh') > -1
    bt['isWin'] = string.find(ua, 'Windows') > -1
    bt['isIEWin'] = bt['isIE'] and bt['isWin']
    bt['isIEMac'] = bt['isIE'] and bt['isMac']
    bt['staticHTML'] = False

    return bt

    
class zogiImage(SimpleItem):
    """einzelnes Image"""
    meta_type="zogiImage"

    manage_options=SimpleItem.manage_options+(
        {'label':'Main config','action':'changeZogiImageForm'},
       )
    
    
    def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
        """init"""
        self.id=id
        self.title=title
        if baseUrl:
            self.baseUrl=baseUrl
        else:
            self.baseUrl="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?"
            
        self.queryString=queryString
        self.content_type=content_type
        self.precondition=precondition

    #def getData(self):
    #    """getUrlData"""
    #    return urllib.urlopen(self.baseUrl+self.queryString)

    def changeZogiImageForm(self):
        """Main configuration"""
        pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiImageForm.zpt')).__of__(self)
        return pt()
    
    def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):
        """change it"""
        self.title=title
        self.baseUrl=baseUrl
        self.queryString=queryString

        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def index_html(self, REQUEST, RESPONSE):
        """service the request by redirecting to digilib server"""
        RESPONSE.redirect(self.baseUrl+self.queryString)
        return ''
        
    def rescale(self,width=None,height=None):
        """andere parameter im querystring"""
        qs=cgi.parse_qs(self.queryString)
        for x in qs.keys():
            if type(qs[x]) is ListType:
                qs[x]=qs[x][0]
        
        if width:
            qs['dw']=width
        if height:
            qs['dh']=height

        
        qsneu=urllib.urlencode(qs)
        self.queryString=qsneu
        return "done"
    
def manage_addZogiImageForm(self):
    """Form for adding"""
    pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
    return pt()


def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
    """add zogiimage"""
    newObj=zogiImage(id,title,baseUrl, queryString)
    self.Destination()._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')



class zogiLib(Folder):
    """digilib frontend with ZOPE"""

    meta_type="zogiLib"
    #xxxx
    security=ClassSecurityInfo()
    
    manage_options = Folder.manage_options+(
            {'label':'Main Config','action':'changeZogiLibForm'},
            )

    def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
        """init"""

        self.id=id
        self.title=title
        self.dlServerURL = dlServerURL
        self.basePath=basePath
        self.layout=layout
        self.dlTarget = dlTarget

        if dlToolbarBaseURL:
            self.dlToolbarBaseURL = dlToolbarBaseURL
        else:
            self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"

    security.declareProtected('View','getLayout')
    def getLayout(self):
        """get Layout"""
        return self.layout
    
    def version(self):
        """version information"""
        return ZOGIVERSION

    def getContextStatic(self):
        """get all the contexts which go to static pages"""
        
        try:
            dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
            contexts=dom.getElementsByTagName("context")

            ret=[]
            for context in contexts:
                name=getUniqueElementText(context.getElementsByTagName("name"))

                link=getUniqueElementText(context.getElementsByTagName("link"))
                if name or link:
                    ret.append((name,link))
            return ret
        except:
            return []

    def getContextDatabases(self):
        """get all dynamic contexts"""
        try:
            dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
            contexts=dom.getElementsByTagName("context")
            ret=[]
            for context in contexts:
                metaDataLinks=context.getElementsByTagName("meta-datalink")
                for metaDataLink in metaDataLinks:
                    db=metaDataLink.getAttribute("db")
                    link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
                    if db:
                        ret.append((db,link))
                metaDataLinks=context.getElementsByTagName("meta-baselink")

                for metaDataLink in metaDataLinks:
                    db=metaDataLink.getAttribute("db")
                    link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
                    if db:
                        ret.append((db,link))

            return ret
        except:

            return []


    def formatHTML(self,url,label=None,viewUrl=None):

        sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
        ret=""
        print label
        if label:
            ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
        for set in sets:
            ret+="<table>"
            for node in set.childNodes:
                if hasattr(node,'tagName'):
                    tag=node.tagName
                    label=node.getAttribute("label")
                    if not label:
                        label=tag
                    text=getText(node.childNodes)
                    ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text)
            ret+="</table>"
        return ret

    
    def getMetaData(self):
        """getMetaData"""
        try:
            dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
        except:
            return "error metadata"
        
        contexts=dom.getElementsByTagName("context")
        ret=[]
        db=self.getDLParam("db")
        ob=self.getDLParam("object")
        
        fn=self.getDLParam("fn")
        pn=self.getDLParam("pn")
        if not fn:
            fn=""
        if not pn:
            pn=""
        if not ob:
            ob=""
            
        for context in contexts:
            metaDataLinks=context.getElementsByTagName("meta-datalink")
            for metaDataLink in metaDataLinks:
                 
                if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1):
                    
                    link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
                    label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
                    url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))

                    return self.formatHTML(link,label,url)

            metaDataLinks=context.getElementsByTagName("meta-baselink")
             
            for metaDataLink in metaDataLinks:
                
                if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1):
                    
                    link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
                    label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
                    url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))

                    return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
        return ret


    def getDLInfo(self):
        """get DLInfo from digilib server"""
        paramH={}
        baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
        try:
            url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING'])
            dom=xml.dom.minidom.parse(url)
            params=dom.getElementsByTagName('parameter')
            for param in params:
                paramH[param.getAttribute('name')]=param.getAttribute('value')
            return paramH
        except:
            return {}


    def createHeadJS(self):
        """generate all javascript tags for head"""
	self.checkQuery()
	bt = self.REQUEST.SESSION.get('browserType', {})
        if bt['staticHTML']:
            return
        
        pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
        return pt()

    def createParamJS(self):
        """generate javascript for parameters only"""
	self.checkQuery()
	bt = self.REQUEST.SESSION['browserType']
        if bt['staticHTML']:
            return

        pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
        return pt()
        
                        
    def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
        """generate Scaler IMG Tag"""
	self.checkQuery()
	bt = self.REQUEST.SESSION['browserType']
        # override with parameters from session
        if  self.REQUEST.SESSION.has_key('scalerDiv'):
            (requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']
        # if not explicitly defined take normal request
        if not requestString:
            requestString = self.getAllDLParams()
        url = self.dlServerURL+'/servlet/Scaler?'+requestString
        # construct bottom and side insets
        b_par = ""
        s_par = ""
        if (bottom != 0) or (side != 0):
            b_par = "-" + str(int(bottom))
            s_par = "-" + str(int(side))
        tag = ""
        if bt['staticHTML']:
            tag += '<div id="scaler"><img id="pic" src="%s&dw=%i&dh=%i" /></div>'%(url, int(width-side), int(height-bottom))
        else:
            if bt['isN4']:
                # N4 needs layers
                tag += '<ilayer id="scaler">'
            else:
                tag += '<div id="scaler">'
            tag += '<script type="text/javascript">'
            tag += "var ps = bestPicSize(getElement('scaler'));"
            # write img tag with javascript
            tag += 'document.write(\'<img id="pic" src="%s&dw=\'+(ps.width%s)+\'&dh=\'+(ps.height%s)+\'" />\');'%(url, s_par, b_par)
            tag += '</script>'
            if bt['isN4']:
                tag += '</ilayer>'
            else:
                tag += '</div>'
        return tag

    def createScalerDiv(self, requestString = None, bottom = 0, side = 0, width=500, height=500):
        """generate scaler img and table with navigation arrows"""
	self.checkQuery()
        if requestString != None or bottom != 0 or side != 0:
            self.REQUEST.SESSION['scalerDiv'] = (requestString, bottom, side, width, height)
        else:
            if self.REQUEST.SESSION.has_key('scalerDiv'):
                # make shure to remove unused parameter
                del self.REQUEST.SESSION['scalerDiv']
                
        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['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()


    def option_js(self):
        """javascript"""
        return sendFile(self, 'js/option.js', 'text/plain')

    def dl_lib_js(self):
        """javascript"""
        return sendFile(self, 'js/dllib.js', 'text/plain')

    def js_lib_js(self):
        """javascript"""
        return sendFile(self, 'js/baselib.js', 'text/plain')

    def optionwindow(self):
        """showoptions"""
	self.checkQuery()
	bt = self.REQUEST.SESSION['browserType']
        if bt['staticHTML']:
            pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
        else:
            tp = "viewingTools.zpt"
            if hasattr(self, tp):
                pt = getattr(self, tp)
	    else:
                pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
                
        return pt()

    def mark1(self):
        """mark image"""
        return sendFile(self, 'images/mark1.gif', 'image/gif')

    def mark2(self):
        """mark image"""
        return sendFile(self, 'images/mark2.gif', 'image/gif')

    def mark3(self):
        """mark image"""
        return sendFile(self, 'images/mark3.gif', 'image/gif')

    def mark4(self):
        """mark image"""
        return sendFile(self, 'images/mark4.gif', 'image/gif')

    def mark5(self):
        """mark image"""
        return sendFile(self, 'images/mark5.gif', 'image/gif')

    def mark6(self):
        """mark image"""
        return sendFile(self, 'images/mark6.gif', 'image/gif')

    def mark7(self):
        """mark image"""
        return sendFile(self, 'images/mark7.gif', 'image/gif')

    def mark8(self):
        """mark image"""
        return sendFile(self, 'images/mark8.gif', 'image/gif')

    def corner1(self):
        """mark image"""
        return sendFile(self, 'images/olinks.gif', 'image/gif')

    def corner2(self):
        """mark image"""
        return sendFile(self, 'images/orechts.gif', 'image/gif')

    def corner3(self):
        """mark image"""
        return sendFile(self, 'images/ulinks.gif', 'image/gif')

    def corner4(self):
        """mark image"""
        return sendFile(self, 'images/urechts.gif', 'image/gif')

    def up_img(self):
        """mark image"""
        return sendFile(self, 'images/up.gif', 'image/gif')

    def down_img(self):
        """mark image"""
        return sendFile(self, 'images/down.gif', 'image/gif')

    def left_img(self):
        """mark image"""
        return sendFile(self, 'images/left.gif', 'image/gif')

    def right_img(self):
        """mark image"""
        return sendFile(self, 'images/right.gif', 'image/gif')


            
    def index_html(self):
        """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)
            
        return pt()


    def storeQuery(self, more = None):
        """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:
                    pv = fm.split('=')
                    dlParams[pv[0]] = pv[1]
                except:
                    pass
                
        # parse digilib mode parameter
        if 'mo' in dlParams:
            if len(dlParams['mo']) > 0:
                modes=dlParams['mo'].split(',')
        else:
            modes=[]
            
        wid = self.getWID()
        self.REQUEST.set('wid', wid)
        self.setSubSession('dlQuery', dlParams)
        self.setSubSession('dlModes', modes)
        self.setSubSession('dlInfo', self.getDLInfo())
        if not self.REQUEST.SESSION.has_key('browserType'):
            self.REQUEST.SESSION['browserType'] = browserCheck(self)
            
        return

    def checkQuery(self):
	"""check if the query has been stored"""
	if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) :
	    print "ZOGILIB: have to store query!!"
	    self.storeQuery()
        return

    def zogilibPath(self, otherbase=None):
        """returns an URL to the zogiLib instance"""
        url = self.REQUEST['URL1']
        # should end with "/"
        if len(url) > 0 and url[-1] != '/':
            url += '/'
        if type(otherbase) is str:
            url += otherbase
        else:
            url += self.basePath
        # should end with "/"
        if len(url) > 0 and url[-1] != '/':
            url += '/'
        return url

    def zogilibAction(self, action, otherbase=None, wid=None):
        """returns a URL with zogilib path, action and wid"""
        url = self.zogilibPath(otherbase)
        url += action
        if wid:
            url += '?wid=' + wid
        else:
            url += '?wid=' + self.getWID()
        return url

    def getSubSession(self, key, default=None):
        """returns an element from a session with a wid"""
        wid = self.getWID()
        return self.REQUEST.SESSION.get(key+'_'+wid, default)

    def setSubSession(self, key, value):
        """puts an element in a session with a wid"""
        wid = self.getWID()
        self.REQUEST.SESSION.set(key+'_'+wid, value)
        return

    def getWID(self):
        """returns a (new) window id"""
        wid = self.REQUEST.get('wid')
        if not wid:
            wid = 'digi_'+str(int(random.random()*10000))
            print "new WID:", wid
        return wid
        
    def getDLParam(self, param, default=None):
        """returns parameter or default"""
        try:
            return self.getSubSession('dlQuery').get(param, default)
        except:
            return default

    def setDLParam(self, param, value):
        """sets parameter"""
        dlParams = self.getSubSession('dlQuery')
        #try:
        dlParams[param] = value
        #except:
        #    self.setSubSession('dlQuery', {param: value})
        return

    def getAllDLParams(self):
        """parameter string for digilib"""
        dlParams = self.getSubSession('dlQuery')
        # save modes
        modes = self.getSubSession('dlModes')
        dlParams['mo'] = string.join(modes, ',')
        # assemble query string
        ret = ""
        for param in dlParams.keys():
            if dlParams[param] is None: continue
            val = str(dlParams[param])
            if val != "":
                ret += param + "=" + val + "&"

        # omit trailing "&"
        return ret.rstrip('&')

        
    def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
        """setze Parameter"""

        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)
            
        return self.display()


    def display(self):
        """(re)display page"""
        if not self.getDLParam('wid'):
            wid = self.getWID()
            self.setDLParam('wid', wid)
            
        params = self.getAllDLParams()
            
        if self.basePath:
            self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
        else:
            self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)

    def getMetaFileName(self):
        url=self.dlServerURL+'/dlContext-xml.jsp?'+self.getAllDLParams()
        return urlbase

    def getToolbarPageURL(self):
        """returns a toolbar-enabled page URL"""
        url=self.dlToolbarBaseURL+self.getAllDLParams()
        return url
    
    def getDLTarget(self):
        """returns dlTarget"""
        self.checkQuery()
        s = self.dlTarget
        if s == None:
            s = ""
#         s = 'dl'
#         if self.getDLParam('fn'):
#             s += "_" + self.getDLParam('fn')
#         if self.getDLParam('pn'):
#             s += "_" + self.getDLParam('pn')
        return s

    def setStaticHTML(self, static=True):
        """sets the preference to static HTML"""
        self.checkQuery()
 	self.REQUEST.SESSION['browserType']['staticHTML'] = static
        return

    def isStaticHTML(self):
        """returns if the page is using static HTML only"""
        self.checkQuery()
	return self.REQUEST.SESSION['browserType']['staticHTML']

    def getPT(self):
        """pagenums"""
        di = self.getSubSession('dlInfo')
        if di:
            return int(di['pt'])
        else:
            return 1
    
    def getPN(self):
        """Pagenum"""
        pn = self.getDLParam('pn')
        try:
            return int(pn)
        except:
            return 1

    def getBiggerWS(self):
        """ws+1"""
        ws = self.getDLParam('ws')
        try:
            return float(ws)+0.5
        except:
            return 1.5
        
    def getSmallerWS(self):
        """ws-1"""
        ws=self.getDLParam('ws')
        try:
            return max(float(ws)-0.5, 1)
        except:
            return 1

    def hasMode(self, mode):
        """returns if mode is in the diglib mo parameter"""
        wid = self.getWID()
        return (mode in self.REQUEST.SESSION['dlModes_'+wid])

    def hasNextPage(self):
        """returns if there is a next page"""
        pn = self.getPN()
        pt = self.getPT()
        return (pn < pt)
   
    def hasPrevPage(self):
        """returns if there is a previous page"""
        pn = self.getPN()
        return (pn > 1)

    def canMoveLeft(self):
        """returns if its possible to move left"""
        wx = float(self.getDLParam('wx') or 0)
        return (wx > 0)

    def canMoveRight(self):
        """returns if its possible to move right"""
        wx = float(self.getDLParam('wx') or 0)
        ww = float(self.getDLParam('ww') or 1)
        return (wx + ww < 1)

    def canMoveUp(self):
        """returns if its possible to move up"""
        wy = float(self.getDLParam('wy') or 0)
        return (wy > 0)

    def canMoveDown(self):
        """returns if its possible to move down"""
        wy = float(self.getDLParam('wy') or 0)
        wh = float(self.getDLParam('wh') or 1)
        return (wy + wh < 1)


    def dl_StaticHTML(self):
        """set rendering to static HTML"""
        self.checkQuery()
        self.REQUEST.SESSION['browserType']['staticHTML'] = True
        return self.display()

    def dl_DynamicHTML(self):
        """set rendering to dynamic HTML"""
        self.checkQuery()
        self.REQUEST.SESSION['browserType']['staticHTML'] = False
        return self.display()
        
    def dl_HMirror(self):
        """mirror action"""
        modes = self.getSubSession('dlModes')
        if 'hmir' in modes:
            modes.remove('hmir')
        else:
            modes.append('hmir')

        return self.display()
       
    def dl_VMirror(self):
        """mirror action"""
        modes = self.getSubSession('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()

    def dl_db(self,db):
        """set db"""
        self.setDLParam('db',db)
        self.display()

    def changeZogiLibForm(self):
        """Main configuration"""
        pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
        return pt()
    
    def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
        """change it"""
        self.title=title
        self.dlServerURL=dlServerURL
        self.basePath = basePath
        self.layout=version
        self.dlTarget = dlTarget

        if dlToolbarBaseURL:
            self.dlToolbarBaseURL = dlToolbarBaseURL
        else:
            self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"

        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')



    ##
    ## odds and ends
    ##

    def repairZogilib(self, obj=None):
        """change stuff that broke on upgrading"""

        msg = ""

        if not obj:
            obj = self.getPhysicalRoot()

        print "starting in ", obj
        
        entries=obj.ZopeFind(obj,obj_metatypes=['zogiLib'],search_sub=1)

        for entry in entries:
            print "  found ", entry
            #
            # replace digilibBaseUrl by dlServerURL
            if hasattr(entry[1], 'digilibBaseUrl'):
                msg += "  fixing digilibBaseUrl in "+entry[0]+"\n"
                entry[1].dlServerURL = re.sub('/servlet/Scaler\?','',entry[1].digilibBaseUrl)
                del entry[1].digilibBaseUrl
                
            #
            # add dlToolbarBaseURL
            if not hasattr(entry[1], 'dlToolbarBaseURL'):
                msg += "  fixing dlToolbarBaseURL in "+entry[0]+"\n"
                entry[1].dlToolbarBaseURL = entry[1].dlServerURL + "/digimage.jsp?"
                
        return msg+"\n\nfixed all zogilib instances in: "+obj.title

          
def manage_addZogiLibForm(self):
    """interface for adding zogilib"""
    pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
    return pt()

def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
    """add dgilib"""
    newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
    self.Destination()._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


class zogiLibPageTemplate(ZopePageTemplate):
    """pageTemplate Objekt"""
    meta_type="zogiLib_pageTemplate"


## def __init__(self, id, text=None, contentType=None):
##         self.id = str(id)
##         self.ZBindings_edit(self._default_bindings)
##         if text is None:
##             text = open(self._default_cont).read()
##         self.pt_edit(text, contentType)

def manage_addZogiLibPageTemplateForm(self):
    """Form for adding"""
    pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
    return pt()

def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,
                           REQUEST=None, submit=None):
    "Add a Page Template with optional file content."

    id = str(id)
    self._setObject(id, zogiLibPageTemplate(id))
    ob = getattr(self, id)
    if not layout: layout = "book"
    ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/zogiLibMain_%s.zpt'%layout)).read(),None)
    if title:
        ob.pt_setTitle(title)
    try:
        u = self.DestinationURL()
    except AttributeError:
        u = REQUEST['URL1']
        
    u = "%s/%s" % (u, urllib.quote(id))
    REQUEST.RESPONSE.redirect(u+'/manage_main')
    return ''