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
import types
import random
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(Image):
    """einzelnes Image"""
    meta_type="zogiImage"

    manage_options=ZopePageTemplate.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 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 ''