def removeStopWords(self,xo):
        """remove stop words from xo"""
        if not hasattr(self,'_v_stopWords'):
            self._v_stopWords=self.stopwords_en.data.split("\n")
    
        x=str(xo)
    
        strx=x.split(" ")
  
        for tmp in strx:
     
            if tmp.lower() in self._v_stopWords:
                del strx[strx.index(tmp)]

        return " ".join(strx)
    
    
    def getGetNeighbourhood(self,obj, wordStr, length=100,tagging=True):
        """finde umgebung um die worte in wordStr, zurueckgegeben wird eine Array mit den Umgebungen von Fundstellen der Worte
        alle Tags werden entfernt, die Fundstellen werden mit <span class="found">XX</span> getaggt, die Umgebungen werden 
        case insensitive gesucht
        @param wordStr: string mit Worten getrennt durch Leerzeichen, Phrasen sind mit " gekennzeichnet
                        "eine phrase", "*"  bezeichnet wildcards und wird ignoriert"
        @param length: optional, default wert 100, 2*length ist die groesse der Umgebung
        @param tagging: optional default wert true, kein span tag wird erzweugt falls tag=false
        """
        
        ret=[] # nimmt das Array auf, dass spaeter zurueckgegeben wird
        ranges=[] #Array mit tupeln x,y wobei x die Position des Anfang und y des Endes der i-ten Umgebung angiebt
        
        wordStr=wordStr.lstrip().rstrip()
        
        def isInRanges(nr,length):
            """test ob eine gegeben Position nr schon irgendwo in einer Umgebung ist, gibt den Index des ersten Wertes aus ranges zurueck, 
            -1, wenn kein Treffer
            
            @param nr: Position die geprueft werden soll
            @param length: Laenge des Wortes das geprueft werden soll
            """
            for x in ranges:
                if (x[0]<=nr) and (nr < (x[1]-length)):
                    return ranges.index(x)
            return -1
                
        # deal with phrases, in Phrasen werden die Leerzeichen durch "_" ersetzt.
        def rep_empty(str):
            x= re.sub(" ","_",str.group(0))
            return re.sub("\"","",x)
            
        wordStr=re.sub("\".*?\"", rep_empty,wordStr)#ersetze leerzeichen in " " durch "_" und loesche "
        
        #deal with wildcards, for our purposes it is enough to delete the wildcard 
        wordStr=wordStr.replace("*","")
        
        words=wordStr.split(" ")
        #if not words is ListType:
        #   words=[words]
        
        
        txtCache = self.en.getHarvestCache();
        txt=  txtCache.get(obj.absolute_url(),None)
       
        if txt==None:
            
            logging.debug("NO CACHE for: "+obj.absolute_url())
            txt=obj.harvest_page(mode="slim")
        
        
        if not txt:
            return ret
        
        soup = BeautifulSoup(txt)
        
        comments = soup.findAll(text=lambda text:isinstance(text, Comment))
        [comment.extract() for comment in comments]
        
        txt = ''.join(soup.findAll(text=True))
        
        
        #txt=re.sub("<.*?>", "", txt) # loesche alle Tags
        for word in words:
            word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "
            pos=0
            
            n=txt.lower().count(word.lower()) # wie oft tritt das Wort auf

            for i in range(n):
                pos=txt.lower().find(word.lower(),pos)

                if pos > 0:
                    x=max(0,pos-length)
                    y=min(len(txt),pos+length)
                  
                    
                    #is word already in one of the results
                    nr=isInRanges(pos,len(word))
                    if nr >=0:# word ist in einer schon gefunden Umgebung, dann vergroessere diese
                        x=min(ranges[nr][0],x)
                        y=max(ranges[nr][1],y)
              
                    str=txt[x:y]
                    if x!=0: #add dots if in the middle of text
                        str="..."+str
                    
                    if y!=len(txt): #add dots if in the middle of text
                        str=str+"..."
                        
                        
                
                    if nr >=0: # word ist in einer schon gefunden Umgebung
                        ranges[nr]=(x,y) # neue Position der Umgebung

                        ret[nr]=str # neue Umgebung
                    else: # andernfalls neue Umgebung hinzufuegen
                        ranges.append((x,y))

                        ret.append(str)
                    
                    pos=pos+len(word)
                else:
                    break;
                
        # now highlight everything        
        if tagging:
            for x in range(len(ret)):
                for word in words:
                    repl=re.compile(word,re.IGNORECASE)
                    ret[x]=repl.sub(""" <span class="found">%s</span>"""%word.upper(),ret[x])

        return ret
    def copyAllImagesToMargin(self):
        """tranformiere alle Bilder in die Margins"""
        projects=self.getTree()
        ret=""
        for project in projects:
            proj=project[3]
            try:
                persons=proj.copyImageToMargin();
            except:
                logging.error("Cannnot do: %s"%repr(project))
                
    def transformProjectsToId(self):
        """trnasformiere zu ID, Hilfsfunktion die die alten Templates analysiert und mit der neuen Liste
        verantwortlicher Personen versieht"""
        projects=self.getTree()
        ret=""
        for project in projects:
            
            proj=project[3]
            persons=proj.identifyNames(proj.getContent('xdata_01'))
            if not hasattr(proj,'responsibleScientistsList'):
                        proj.responsibleScientistsList=[]
                        
            for person in persons.items():
              
                if len(person[1]) >1: #nicht eindeutig
                    ret+="nicht eindeutig ---  %s:  %s\n"%(proj.getId(),person[0])
                    
                elif len(person[1]) ==0: #kein eintrage
                    ret+="kein eintrag---  %s:  %s\n"%(proj.getId(),person[0])
                    proj.responsibleScientistsList.append((person[0],""))
                else:           
                    proj.responsibleScientistsList.append((person[0],person[1][0].getObject().getKey()))
        
        return ret
          
                
    def harvestProjects(self):
        """harvest"""
        folder="/tmp"
        try:
            os.mkdir("/tmp/harvest_MPIWG")
        except:
            pass
        founds=self.ZopeFind(self.aq_parent.projects,obj_metatypes=['MPIWGProject'],search_sub=1)
        for found in founds:
            txt=found[1].harvest_page()
        
            if txt and (txt != ""):
                name=found[0].replace("/","_")
                fh=file("/tmp/harvest_MPIWG/"+name,"w")
                fh.write(txt)
                fh.close()
                
                
                
    def generateNameIndex(self):
        """erzeuge einen index verwendeter personen"""
        import psycopg
        o = psycopg.connect('dbname=authorities user=dwinter password=3333',serialize=0) 
        results={}
        print self.fulltext.historicalNames.items()
        for nameItem in self.fulltext.historicalNames.items(): #gehe durch alle namen des lexikons
            
            c = o.cursor() 
            name=nameItem[0]
            print "check",name
            c.execute("select lastname,firstname from persons where lower(lastname) = '%s'"%quote(name))
            tmpres=c.fetchall()
            firstnames=[result[1] for result in tmpres] # find all firstnames
            if tmpres:
                lastname=tmpres[0][0]
                
            for found in self.fulltext({'names':name}):
                if found.getObject().isActual():
                    for nh in found.getObject().getGetNeighbourhood(name, length=50,tagging=False): #hole umgebung
                        #schaue nun ob der vorname hinter oder vor dem name ist
                        position=nh.find(lastname)
                        # vorher
                        #print "NH",nh
                        bevorS=nh[0:position].split()
                        #print "BV",bevorS
                        if len(bevorS)>1:
                            try:
                                bevor=[bevorS[-1],bevorS[-2]]
                            except:
                                bevor=[bevorS[0]]
                        else:
                            bevor=[]
                        #nachher
                        behindS= re.split("[,|;| ]",nh[position:]) 
                        #print "BH",behindS
                        if len(behindS)>2:
                            try:
                                behind=behindS[1:3]
                            except:
                                behind=[bevorS[1]]
                        else:
                            behind=[]
                        for firstname in firstnames:
                            if firstname in bevor+behind: #Namen wie mit Adelspraedikaten werden so erstmal nich gefunden
                                id="%s,%s"%(lastname,firstname)
                                if not results.has_key(id):
                                    results[id]=[]
                                objId=found.getObject().getId()
                                if not (objId in results[id]):
                                    print "d %s for %s"%(id,objId)    
                                    results[id].append(objId)    
            self.nameIndex=results
        return results
                    
    def editNameIndexHTML(self):
        """edit the name index"""
        if not hasattr(self,'nameIndexEdited'): # falls editierter index noch nicht existiert, kopiere automatisch erstellten
            self.nameIndexEdited=copy.copy(self.nameIndex)
            print "huh"
        #self.nameIndexEdited=copy.copy(self.nameIndex)
        #print self.nameIndexEdited
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalNames.zpt')).__of__(self)
        return pt()
    
    def getNamesInProject(self,projectId):
        """get all names ofnameIndexEdited which are references in projec with projectId"""
        
        ret=[]
        for name in self.nameIndexEdited.keys():
            if projectId in self.nameIndexEdited[name]:
                ret.append(name)
        
        return ret
    
    def editNameIndex(self,RESPONSE=None,name=None,occurrances=None,submit=None):
        """edit the index"""
        nI=self.nameIndexEdited # mI introduced to make sure that changes to nameIndexEdited are know to ZODB
        if submit=="delete":
           

            dh=getattr(self,'deletedHistoricalNames',{})
            
            if type(dh) is ListType:
                dh={}
            if not dh.has_key(name):
                dh[name]=occurrances.split("\n")
            else:
                dh[name]+=occurrances.split("\n")
            
            self.deletedHistoricalNames=dh
            
            del self.nameIndexEdited[name]
            
        
        elif (submit=="change"):
            
            nI[name]=occurrances.split("\n")[0:]
            
        elif (submit=="add"):
            if not nI.has_key(name):
                nI[name]=occurrances.split("\n")
            else:
                nI[name]+=occurrances.split("\n")
    
        self.nameIndexEdited=nI
   
      
        if RESPONSE is not None:
            RESPONSE.redirect('editNameIndexHTML')
        
    
    
    def restoreIndex(self):
        """restore"""
        self.nameIndexEdited=self.nameIndex
        return "done"