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()