Return to ECHO_helpers.py CVS log

Up to [Repository] / ECHO_content

small fix in add_coordinates

import re
import string
import socket
import urllib
import string
import xml.dom.minidom
import types
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from OFS.SimpleItem import SimpleItem
from Globals import package_home
import Globals
from AccessControl import ClassSecurityInfo
import os.path

displayTypes = ['ZSQLExtendFolder','ZSQLBibliography','ECHO_group','ECHO_collection','ECHO_resource','ECHO_link','ECHO_sqlElement','ECHO_pageTemplate','ECHO_externalLink','ImageCollectionIFrame','VLP_resource','VLP_essay','ECHO_ZCatalogElement','ImageCollection','versionedFileFolder','ECHO_movie']

def content_html(self,type):
        """template fuer content"""
        #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
        #
        #if templates:
        #    return templates[0][1]()

        if hasattr(self,type+"_template"):
            obj=getattr(self,type+"_template")
            return obj()
        else:
	    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%type)).__of__(self)
            pt.content_type="text/html"
            return pt()
    
    

class ECHO_basis:
    """basis eigenschaften fuer echo objekte"""
    security=ClassSecurityInfo()
    security.declarePublic('getImageTag')
    def getImageTag(self):
	    """sollte uerberschrieben werden, falls von der Klasse eine imagetag zurueckkommt"""
	    
	    return ""
    
    def showRDF(self):
	    """showrdf"""
            self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
	    ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""

	    ret+=self.getRDF(urn="echo:collectionroot")+"\n"


	    ret+="""</RDF:RDF>"""
    	    return ret 

  
    def RDF(self):
	    """showrdf"""
            self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
	    ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""

	    ret+=self.getRDF(urn=self.absolute_url())+"\n"


	    ret+="""</RDF:RDF>"""
    	    return ret 

  
    def createSubElementRDF(self,urn=None):
	    """rdf list"""
	    if not urn:
		    urn=self.absolute_url()
	    ret=""

	    rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn
	    flag=0
	    
	    li="""<RDF:li RDF:resource="%s" />\n"""
	    if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
		    nurn=self.absolute_url()+'/getFullTextXML'
		    rettemp+=li%nurn
		    flag=1
	    if not ('<error>' in self.getImageView(noredirect='Yes')):
		    nurn=self.absolute_url()+'/getImageView'
		    rettemp+=li%nurn
		    flag=1


	    if not ('<error>' in self.showMetaDataXML()):
		    nurn=self.absolute_url()+'/showMetaDataXML'
		    rettemp+=li%nurn
		    flag=1
		    
	    rettemp+="</RDF:Seq>"

	    if flag==1:
		    ret+=rettemp
		    
	    if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
                    nurn=self.absolute_url()+'/getFullTextXML'	
		    ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext")

	    if not ('<error>' in self.getImageView(noredirect='Yes')):
                    nurn=self.absolute_url()+'/getImageView'
		    ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview")
		    
	    if not ('<error>' in self.showMetaDataXML()):
                    nurn=self.absolute_url()+'/showMetaDataXML'
		    ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData")

	    return ret
	    
    def content_html(self,type="collection"):
	    """template fuer content bei einbau und ECHO_Umgebung"""
	    
	    return content_html(self,type)
        
    def getTitle(self):
	"""title"""
	return self.decode(self.title)
	try:
		return self.title.encode('utf-8','ignore') 
	except:
		self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
		return self.title.encode('utf-8','ignore') 
	
    def getLabel(self):
	"""title"""
	if not hasattr(self,'label'):
		self.label=""
		
	if self.label=="":
		ret=self.getTitle()
		if ret=="":
			ret=self.getId()
		return ret
	
	return self.decode(self.label)
	try:
		return self.label.encode('utf-8','ignore') 
	except:
		self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
		return self.label.encode('utf-8','ignore') 
	
    
    def changeECHOEntriesForm(self):
        """change Entries for the ECHO Navigation environment"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHOEntriesForm')).__of__(self)
        return pt()
    
    def changeECHOEntries(self,label,weight,description,queryString,RESPONSE=None):
        """change Entries for the ECHO Navigation environment
        @param label: label fuer die Navigation"""
        self.label=label
        self.weight=weight
        self.description=description
	self.queryString=queryString
        
        if RESPONSE:
            RESPONSE.redirect("manage_main")

    manage_options=({'label':'change ECHO Navigation Entries','action':'changeECHOEntriesForm'},)


    def hasOverview(self):
        """returns if there is an overview graphics"""
	return hasattr(self, 'overview')

    def hasParentOverview(self):
        """returns if the parent has an overview graphics"""
	return hasattr(self.aq_parent, 'overview')

    def getOverview(self):
        """map overview graphics"""
        #return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
	if self.hasOverview():
	    return getattr(self, 'overview')
	return None

    def getMapAreas(self):
        """returns the list of MapAreas"""
	# get all contained MapAreas
        areas = [res[1] for res in self.ZopeFind(self, obj_metatypes=('MapArea'))]
	return areas

    def addMapArea(self, newarea):
	"""add a map area to this object"""
	if (newarea.id is None):
	    # create new id
	    ids = [a.id for a in self.getMapAreas()]
	    i = len(ids)
	    while ("a%02d"%i in ids):
		# if it exists, try the next one
		i += 1
	    newarea.id = "a%02d"%i
	self._setObject(newarea.id, newarea)

    def getMapText(self):
        """returns the MapText"""
	# get (the first) contained MapText
        res = self.ZopeFind(self, obj_metatypes=('ECHO_mapText'))
	if len(res) > 0:
	    text = res[0][1]
	    return text
	return None

    def ECHO_graphicEntry(self):
        """change map coordinates"""
        if self.hasParentOverview():
            pt=zptFile(self, 'zpt/ECHO_draw.zpt')
            return pt()
        else:
            return "NO OVERVIEW GRAPHICS"

    def ECHO_addCoords(self,RESPONSE=None):
        """change or add MapArea"""
	#return self.REQUEST
	# change existing areas
	for area in self.getMapAreas():
	    id = area.getId()
	    if self.REQUEST.has_key('del.'+id):
		# delete this area
		self._delObject(id)
		# return to same menu
		if RESPONSE is not None:
		    RESPONSE.redirect('ECHO_graphicEntry')
		return
	    # modify this area
	    coordstring = self.REQUEST.get('coords.'+id, '')
	    coords = string.split(coordstring, ',')
	    angle = self.REQUEST.get('angle.'+id, '0')
	    type = self.REQUEST.get('type.'+id, 'area')
	    permanent = self.REQUEST.get('permanent.'+id, '')
	    if len(coords) == 4:
		area.setCoordString(coordstring)
		area.setAngle(angle)
		area.setType(type)
		area.setPermanent(permanent)
	# add new area
	if self.REQUEST.has_key('add'):
	    coordstring = self.REQUEST.get('coords.new', '')
	    coords = string.split(coordstring, ',')
	    angle = self.REQUEST.get('angle.new', '0')
	    type = self.REQUEST.get('type.new', 'area')
	    permanent = self.REQUEST.get('permanent.new', '')
	    if len(coords) == 4:
		coords.append(angle)
		area = MapArea(None, coords, type=type, permanent=permanent)
		self.addMapArea(area)
	# return to edit area menu
	if RESPONSE is not None:
	    RESPONSE.redirect('ECHO_graphicEntry')

    def createJSAreas(self, areas):
        """create area calls for JavaScript"""
        js="\n"
        for ob in areas:
	    js+="""addArea('%s', 'overview', %s, '%s', '%s');\n"""%(ob.getFullId(),ob.getCoordString(),ob.getType(),ob.isPermanent())
        return js

    def createMapHead(self):
        """create javascript include and script tags for head"""
        pt=zptFile(self, 'zpt/ECHO_content_map_frag_js')
        return pt()

    def createMapImg(self):
	"""generate img-tag for map"""
	bt = BrowserCheck(self)
	tag = ""
	src = self.getOverview().absolute_url()
	if bt.isN4:
	    # N4 needs ilayer to create an id
	    tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
	else:
	    # img with id
	    tag += '<img id="overview" src="%s" />'%src
	return tag
        
    def createParentMapImg(self):
	"""generate img-tag for map of parent"""
	return self.aq_parent.createMapImg()

    def createMapLink(self, ob, text=None, target="_blank"):
	"""generate map link"""
	bt = BrowserCheck(self)
	id = ob.getFullId()
	link = ob.getLinkId()
	if text is None:
	    text = ob.getLabel()
	if text is None:
	    text = "link"
	tiptext = ob.getTip()
	tag = ""
	if bt.isN4:
	    # N4 needs layer for highlighting
	    tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s"'%(id,id,id,link,target)
	    tag += ">" + text + "</a></ilayer>"
	else:
	    # a-element
	    tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s"'%(id,id,id,link,target)
	    if tiptext:
		tag += ' title="%s"'%tiptext
	    tag += ">" + text + "</a>"
	return tag

    def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil", circlesrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/kreis", target="_blank"):
	"""generate map link image, text and other stuff"""
	bt = BrowserCheck(self)
	id = ob.getFullId()
	link = ob.getLinkId()
	tiptext = ob.getTip()
	tag = ""

	if bt.isN4:
	    #
	    # N4 needs layer and img elements
	    #
	    tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
	    if ob.isTypeArrow():
		# N4 - Arrow
	        rot = ob.angle
		marksrc = arrowsrc
		if float(rot) < 0:
		    marksrc = circlesrc
		tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,marksrc,rot)
	    else:
		# N4 - Area
		tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
		if tiptext:
		    tag += ' alt="%s"'%tiptext
		tag += ' /></a>'
	    tag += '</layer>'
	else:
	    #
	    # (more or less) DOM capable browser
	    #
	    tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s">'%(id,id,id,link,target)
	    if ob.isTypeArrow():
		# DOM - Arrow
		rot = ob.angle
		marksrc = arrowsrc
		if float(rot) < 0:
		    marksrc = circlesrc
		if bt.isIEWin and bt.versIE > 5:
		    # IE/Win 5.5 has "feature" for PNG transparency
		    tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none; border-width=1px; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'%s&rot=%s\');"><img style="visibility:hidden" src="%s&rot=%s" /></span>'%(id,marksrc,rot,marksrc,rot)
		else:
		    # arrow image
		    tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,marksrc,rot)
	    elif ob.isTypeText():
		# DOM - Text
		tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
		tag += '><div id="t.%s" class="maptext"'%(id)
		tag += 'style="visibility:hidden">'
		tag += ob.getText()
		tag += '</div></div>'
	    else:
		# DOM - Area
		if bt.isIE:
		    # IE needs transparent img for area
		    tag += '<img id="i.%s" border="0" style="position:absolute; top:-100px; left:-100px;" src="trans_img"'%(id)
		    if tiptext:
			tag += ' title="%s"'%tiptext
		    tag += " />"
		else:
		    # empty div for area
		    tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
		    if tiptext:
			tag += ' title="%s"'%tiptext
		    tag += '> </div>'
	    tag += '</a>'
	return tag


    #ende der echo erweiterungen


def toList(field):
    """Einzelfeld in Liste umwandeln"""
    if type(field)==types.StringType:
        return [field]
    else:
        return field

def getText(nodelist):
    rc = ""
    for node in nodelist:
    	if node.nodeType == node.TEXT_NODE:
           rc = rc + node.data
    return rc

def getTextFromNode(nodename):
    nodelist=nodename.childNodes
    rc = ""
    for node in nodelist:
    	if node.nodeType == node.TEXT_NODE:
           rc = rc + node.data
    return rc


def readFieldFromXML(meta_url,parent,field):
	"""lesespezifisches metadatum"""
	
	try:
		dom=xml.dom.minidom.parse(meta_url)

	except:
		try:
			fh=urllib.urlopen(meta_url)
			dom=xml.dom.minidom.parse(fh)
	        except:
			return None
	if not dom: return None

	parent=dom.getElementsByTagName(parent)
	if not parent: return None

	field=parent[0].getElementsByTagName(field)

	if not field: return None

	return getText(field[0].childNodes)
	
	
	      
def urlopen(url):
	"""urlopen mit timeout"""
	socket.setdefaulttimeout(2)
	ret=urllib.urlopen(url)
	socket.setdefaulttimeout(5)
	return ret
#	urlopener = urllib.URLopener()
#
#	try:		
#		con = urlopener.open(url)
#		return con
#	except timeoutsocket.Timeout:
#		return None





def checkOnlyOneInGroup(object): 
	"""check if object is a group and if it containt only one element it return this element"""
	displayedObjects=object.ZopeFind(object,obj_metatypes=displayTypes)
	if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object

		return displayedObjects[0][1]
	else:		return object

def getSubCols(self, sortfield=None, subColTypes=displayTypes, sortFieldMD=None,searchMD=None):
	
	
	def sort(x,y):
		return cmp(x[0],y[0])
	
	def sortfnc(sortfield,x,y):
		try:
			xa=x[1].getMDValue(sortfield)
		except:
			xa=""
		try:
			ya=y[1].getMDValue(sortfield)
		except:
			ya=""
		return cmp(xa,ya)
	
	sortWithMD = lambda sortfield : (lambda x,y : sortfnc(sortfield,x,y))
        ids=[]
	displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes)

	
	for entry in displayedObjects:

			
		object=entry[1]
		if searchMD and hasattr(object,'getMDValue'):
			flag=0
			for field in searchMD.keys():
				if object.getMDValue(field)==searchMD[field]:
					flag=1
				else:
					flag=0
					break
			if flag==1:
				ids.append(object)
		else:
			ids.append(object)

	if not sortfield:
            sortfield=getattr(self,'sortfield','weight')

            
        tmplist=[]

        for x in ids:
		
		if hasattr(x,sortfield):
			try:
				tmp=int(getattr(x,sortfield))
			except:
				tmp=getattr(x,sortfield)
				
		else:
			tmp=10000000
			
		tmplist.append((tmp,x))

	if not sortFieldMD:
		tmplist.sort(sort)
	else:
		tmplist.sort(sortWithMD(sortFieldMD))
	
        return [x for (key,x) in tmplist]

def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
        """Rerender all Links"""
	ret=""
	
        if not obj:
            obj = self
            
        entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)

        for entry in entries:
		if entry[1].meta_type == 'ECHO_resource':
			try:
				entry[1].ECHO_getResourceMD(template="no")
                                if "title" in types:
                                    entry[1].generate_title()
                                if "label" in types:
                                    entry[1].generate_label()
				ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
			except:
				ret+="Error:"+entry[0]+"<br>"

		
                
                
        return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"

def reloadMetaDataFromStorage(self,RESPONSE=None):
	    """copy metadata from the storage to ECHO"""
	    ret=""
	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)

	    for resource in resources:
		    x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"
		    ret+=x

	    if RESPONSE is not None:
		    #RESPONSE.redirect('./manage_main')
		    return "<html><body>"+ret+"</html></body>"

	    return ret
    
def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
	    """rdf"""
	    
	    ret=""
	    about="""<RDF:Description RDF:about="%s">"""
	    name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""
	    link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""
	    clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""
	    #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""
	    type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""
            #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""	
	    if not urn:
		    #urn="urn:"+re.sub('/',':',self.absolute_url())
		    urn=self.absolute_url()
	    about2=about%urn
	    if not nameDef:
		    if hasattr(self,'label') and not (self.label==""):
			    name2=name%self.label
		    elif not self.title=="":
			    name2=name%self.title
		    else:
			    name2=name%self.getId()

		    name2=re.sub('&','&amp;',name2)
	    else:
		    name2=name%nameDef

	    linkURL=re.sub('http:','',linkURL)
	    linkURL2=re.sub('&','&amp;',linkURL)
	    link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))
	    clickable2=clickable%"true"

	    if not typeName:
		    type2=type%self.meta_type
	    else:
		    type2=type%typeName
	    
	    #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
	    ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
	    return ret
    
def getCopyrightsFromForm(self,argv): 
	medias={}
	partners={}
	copyrights={}
	
	copyrightsFinal=[]
	for arg in argv.keys():
		
		if arg[0:5]=='media':
			nm=int(arg[5:])
			medias[nm]=argv[arg]
		elif arg[0:5]=='partn':
			nm=int(arg[5:])
			partners[nm]=argv[arg]
		elif arg[0:5]=='copyr':
			nm=int(arg[5:])
			copyrights[nm]=argv[arg]



	copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]
	for copyright in copyrightsList:
		
		if copyright[2]=='institution0000':
			copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))
		else:
			if not copyright[0]=='':
				copyrightsFinal.append(copyright)
		
			
	return copyrightsFinal

#List of different types for the graphical linking viewer
viewClassificationListMaster=['view point','area']


def checkDiffs(self,metadict):
	    """check differences"""

	    

    
	    def NoneToEmpty(obj):
		    if obj:
			    return obj
		    else:
			    return ""

	    
	    
	    diffs={}
	    
	    tags=self.findTagsFromMapping(self.contentType)
	    self.referencetypes=tags[2]
	    self.fields=tags[3]
	    
    
	    for field in tags[1]:
		    try:
			    if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
				    diffs[self.getFieldTag(tags,field)]=1
			    else:
				    
				    diffs[self.getFieldTag(tags,field)]=0
		    except:
			    diffs[self.getFieldTag(tags,field)]=0
			    
	    return diffs
    

def zptFile(self, path, orphaned=False):
    """returns a page template file from the product"""
    if orphaned:
	# unusual case
	pt=PageTemplateFile(os.path.join(package_home(globals()), path))
    else:
	pt=PageTemplateFile(os.path.join(package_home(globals()), path)).__of__(self)
    return pt


def findObjectPath(startobject, filename):
    """returns the object with the name filename starting at startobject"""
    if startobject is None:
	return None
    paths = filename.split('/')
    object = startobject
    for path in paths:
	    
        if hasattr(object, path):
	    object = getattr(object, path)
	else:
	    object = None
	    break
    return object


def zptObjectOrFile(self, filename, localdir='zpt', orphaned=False):
    """returns a page template instance or a file from the product"""
    # look for an object called path
    pt = findObjectPath(self, filename)
    # the object should also not be a python function
    if (pt is None) or isinstance(pt, types.FunctionType):
	# get a ZPT file
	pt = zptFile(self, localdir+'/'+filename, orphaned=orphaned)
    return pt


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


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

		
def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):
	"""Einlesen der Metadaten und und erstellen des geaenderten XML file"""

	def updateTextToolNode(tag,value):

		metanode=dom.getElementsByTagName('texttool')[0]
		try:
			nodeOld=metanode.getElementsByTagName(tag)
		except:
			nodeOld=None
			
		if nodeOld:
			metanode.removeChild(nodeOld[0]).unlink()

		node=dom.createElement(tag)
		nodetext=dom.createTextNode(value)
		node.appendChild(nodetext)
		metanode.appendChild(node)

	if xmlfrag:
		geturl="""<?xml version="1.0" ?>
                           <resource type="MPIWG">
			   <meta>
			    <bib type="Book">
	                    </bib>
			    </meta>
			    </resource>"""
		dom=xml.dom.minidom.parseString(geturl)
	else:
		try:
			geturl=""
			for line in urlopen(url).readlines():
				geturl=geturl+line


		except:
			return (None,"XCannot open: "+url)

		try:
			dom=xml.dom.minidom.parseString(geturl)
		except:
			return (None,"Cannot parse: "+url+"<br>"+geturl)

	

	metanodes=dom.getElementsByTagName('bib')

	if not metanodes:
		metanodes=dom.getElementsByTagName('archimedes')

	metanode=metanodes[0]

	for metaData in metadict.keys():
		
		try:
			nodeOld=metanode.getElementsByTagName(metaData)
		except:
			nodeOld=None
			
		if nodeOld:
			metanode.removeChild(nodeOld[0]).unlink()
		else:
			# try also old writing rule - instead of _:
			try:
				nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
			except:
				nodeOld=None
				
			if nodeOld:
				metanode.removeChild(nodeOld[0]).unlink()

		metanodeneu=dom.createElement(metaData)
                metanodetext=dom.createTextNode(metadict[metaData])
		#try:
			#metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
		#except:
			#metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
		metanodeneu.appendChild(metanodetext)
		metanode.appendChild(metanodeneu)


	
	
	
	if project:
		updateTextToolNode('project',project)

	if startpage:
		updateTextToolNode('startpage',startpage)

	if topbar:
		updateTextToolNode('toptemplate',topbar)

	if thumbtemplate:
		updateTextToolNode('thumbtemplate',thumbtemplate)

	if xslt:
		updateTextToolNode('xslt',xslt)

	
	if digiliburlprefix:
		updateTextToolNode('digiliburlprefix',digiliburlprefix)
	
        try:	
	 return dom.toxml().encode('utf-8')
	except:
	 return dom.toxml('utf-8')

	
	
def readMetadata(url):
    """Methode zum Auslesen der Metadateninformation zu einer Resource
    Vorerst noch Typ bib"""
    
    metadict={}
    
    try:
        geturl=""
        for line in urlopen(url).readlines():
            geturl=geturl+line
        
        
    except:
        return (None,"Cannot open: "+url)

    try:
        dom=xml.dom.minidom.parseString(geturl)
    except:
	    return (None,"Cannot parse: "+url+"<br>"+geturl)

    metanode=dom.getElementsByTagName('bib')
    metadict['bib_type']='Book'
    if len(metanode)==0:
        metanode=dom.getElementsByTagName('archimedes')
        metadict['bib_type']='Archimedes'
        
        
    if not len(metanode)==0:    
        metacontent=metanode[0].childNodes
    
        try:
            metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
        except:
            """nothing"""
        
        for node in metacontent:
		try:
			#print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)
			#metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
			metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
		
		except:
			"""nothing"""


    return metadict,""
    

class MapArea(SimpleItem):
    """simple class to hold coordinates"""

    meta_type = 'MapArea'
    # Create a SecurityInfo for this class.
    security = ClassSecurityInfo()
    security.setDefaultAccess("allow")
    # type constants
    TYPE_AREA = 'area'
    TYPE_ARROW = 'arrow'
    TYPE_TEXT = 'text'
	
    def __init__(self, id, coords, label=None, type=None, tip=None, permanent=False):
	"""init"""
	self.coords = coords[0:4]
	if len(coords) > 4:
	    self.angle = coords[4]
	else:
	    self.angle = 0
	self.id = id
	self.label = label
	self.setType(type)
	self.tip = tip
	self.permanent = permanent

    def setCoords(self, coords):
	"""sets the coords"""
	self.coords = coords

    def getCoordString(self):
	"""returns coordinates as a string"""
	return string.join(self.coords, ',')

    def setCoordString(self, coordstring):
	"""sets coordinates from a string"""
	coords = string.split(coordstring, ',')
	self.coords = [c.strip() for c in coords]

    def getFullId(self, prefix=None):
	"""returns the id with prefixed parent id"""
	if prefix is None:
	    if hasattr(self, 'aq_parent'):
		prefix = self.aq_parent.id
	    else:
		prefix = "id"
	fid = prefix + "." + self.id
	return fid

    def getType(self):
	"""returns the type"""
	return self.type

    def setType(self, type):
	"""sets the type"""
	if type == MapArea.TYPE_ARROW:
	    self.type = MapArea.TYPE_ARROW
	elif type == MapArea.TYPE_AREA:
	    self.type = MapArea.TYPE_AREA
	elif type == MapArea.TYPE_TEXT:
	    self.type = MapArea.TYPE_TEXT
	else:
	    self.type = MapArea.TYPE_AREA
	    
    def isTypeArea(self):
	"""returns if the type is area"""
	return self.type == MapArea.TYPE_AREA

    def isTypeArrow(self):
	"""returns if the type is arrow"""
	return self.type == MapArea.TYPE_ARROW

    def isTypeText(self):
	"""returns if the type is text"""
	return self.type == MapArea.TYPE_TEXT

    def getAngle(self):
	"""returns the angle"""
	return self.angle

    def setAngle(self, angle):
	"""sets the angle"""
	self.angle = angle

    def getTip(self):
	"""returns the popup text"""
	# patch old version
	if not hasattr(self, 'tip'):
	    self.tip = self.text

	if self.tip is None:
	    if hasattr(self, 'aq_parent'):
		parent = self.aq_parent
		if parent.contentType == 'text-popup':
		    return parent.description
	return self.tip

    def setTip(self, text):
	"""sets the text"""
	self.tiptext = text

    def getText(self):
	"""returns the text fpr the area"""
	if hasattr(self, 'aq_parent'):
	    parent = self.aq_parent
	    text = parent.getMapText()
	    if text is not None:
		return text.document_src()
	return ""

    def getLabel(self):
	"""returns the link label"""
	if self.label is None:
	    if hasattr(self, 'aq_parent'):
		return self.aq_parent.label or self.aq_parent.id
	return self.label

    def setLabel(self, label):
	"""sets the label"""
	self.label = label

    def isPermanent(self):
	"""returns the permanent state"""
	# patch old objects
	if not hasattr(self, 'permanent'):
	    self.permanent = False
	return self.permanent

    def setPermanent(self, state):
	"""sets the permanent state"""
	if state:
	    self.permanent = True
	else:
	    self.permanent = False

    def getLinkId(self):
	if hasattr(self, 'aq_parent'):
	    return self.aq_parent.id
	return self.id

# call this to initialize framework classes, which
# does the right thing with the security assertions.
Globals.InitializeClass(MapArea)


class MapText(ZopePageTemplate):
    """class to hold text for map areas"""

    meta_type = 'ECHO_mapText'
    # Create a SecurityInfo for this class.
    security = ClassSecurityInfo()
    security.setDefaultAccess("allow")
	
    _default_content_fn = os.path.join(package_home(globals()),
                                       'html', 'ECHO_mapText_default.html')

    def __init__(self, id, text=None, content_type=None):
        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)

# Product registration and Add support
manage_addMapTextForm = PageTemplateFile(
    'zpt/AddECHO_mapText', globals(), __name__='manage_addMapTextForm')

def manage_addMapText(self, id, title=None, text=None,
                           REQUEST=None, submit=None):
    "Add a Map Text with optional file content."

    id = str(id)
    if REQUEST is None:
        self._setObject(id, MapText(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 = MapText(id, text)
        else:
            zpt = MapText(id, file, headers.get('content_type'))

        self._setObject(id, zpt)
        if title:
            ob = getattr(self, id)
            ob.pt_setTitle(title)

        try:
            u = self.DestinationURL()
        except AttributeError:
            u = REQUEST['URL1']

        if submit == " Add and Edit ":
            u = "%s/%s" % (u, urllib.quote(id))
        REQUEST.RESPONSE.redirect(u+'/manage_main')
    return ''

# call this to initialize framework classes, which
# does the right thing with the security assertions.
Globals.InitializeClass(MapText)