# ****************************************************
# Name des Moduls: mainframe
# Name des Projekts: TaxoSearch
#
# Autor(en):
#        Thorsten Beinhorn, Vesna Cvoro,
#        Khaled Dhaoui und Christian Pretzsch 
#
# Aufgaben des Moduls: siehe Code Dokumentation TaxoSearch
# 
#
# Datum der letzten Aenderung: 26.11.2003
# ****************************************************


from mod_taxosearch import *
from mod_wordnet import *
from Tkinter import *
from string import *
from os import *
import webbrowser
import time
import sys
import re

############################## BEGIN OF CLASS MainFrame #######################################
# This class creates the main application window containing with all other types of
#sub frames i.e. ResultFrame

class MainFrame(Frame):
	def __init__(self, master):
		self.Master=master
		self.Ostdout=sys.stdout
		Frame.__init__ (self, self.Master, width=1024, height=768, bg="gray")
		self.pack()
		self.TaxoObject=TaxoSearch()
		self.WordnetObject=Wordnet()
		self.lstQuery=[]
		self.lstRelevantWords=[]
		self.dicQueryVector={}
		
		self.SearchFrame=SearchFrame(self)
		self.WordnetFrame=WordnetFrame(self)
		system("cls")
		print 'Welcome to TaxoSearch!'
		
	def SwitchToWhileSearch(self, QueryString):
		self.SearchFrame.place_forget()
		self.WordnetFrame.place_forget()
		self.PseudoSearchFrame=PseudoSearchFrame(self, QueryString)
		self.WhileSearchFrame=WhileSearchFrame(self)
		sys.stdout=self.WhileSearchFrame
		self.update_idletasks()
	
	def SwitchToResults(self):
		print 'show results'
		sys.stdout=self.Ostdout
		self.PseudoSearchFrame.place_forget()
		self.WhileSearchFrame.place_forget()
		self.PriorityFrame=PriorityFrame(self)
		self.ResultFrame=ResultFrame(self)
		self.PageRanking()
		self.RankingFrame=RankingFrame(self)
		self.RankingFrame.Update("")
		
	def SwitchToSearch(self, Mode):
	
		if Mode==1:
			self.PseudoSearchFrame.place_forget()
			self.WhileSearchFrame.place_forget()
		elif Mode==2:
			self.PriorityFrame.place_forget()
			self.ResultFrame.place_forget()
			self.RankingFrame.place_forget()

		self.SearchFrame=SearchFrame(self)
		self.WordnetFrame=WordnetFrame(self)
		sys.stdout=self.Ostdout
		
	def PageRanking(self):
		self.ResultFrame.Update(self.TaxoObject.doPageRanking(self.dicQueryVector))
		
############################## END OF CLASS MainFrame #######################################

############################## BEGIN OF CLASS SearchFrame ###################################
#This class contains the text entry for building the google query string
# it's also responsible for creating a google readable query syntax
# the complete search mechanism is triggered by this frame

class SearchFrame(Frame):
	def __init__(self, master):
		self.Master=master
		self.Autosyn=IntVar()
		self.Autosyn.set(0)
		Frame.__init__ (self, self.Master, width=1024, height=100, relief=RAISED, bd=1)
		self.place(relx=0.0, rely=0.0)
		
		#entry controls
		self.QueryLabel=Label(self, text="Please enter your query words here:", font="Helvetica 10", fg="blue")
		self.QueryEntry=Entry(self, width=100)
		self.QueryButton=Button(self, text='Start internet search', font="Helvetica 10 bold", fg="blue", command=self.doSearch)
		self.AutoSynCheckbutton=Checkbutton(self, text="Autogenerate synonyms", variable=self.Autosyn, font="Helvetica 10", fg="blue")
		
		#placement of controls
		self.QueryLabel.place(x=40, y=20)
		self.QueryEntry.place(x=40, y=40)
		self.QueryButton.place(x=650, y=38)
		self.AutoSynCheckbutton.place(x=35,y=60)
				
		#bindings
		self.QueryEntry.bind("<KeyRelease>", self.KeyRelease)
		self.QueryEntry.bind("<ButtonRelease-1>", self.KeyRelease)
		self.QueryEntry.focus()	#set focus to entry
		
	def doSearch(self):
		QueryString=self.QueryEntry.get()
		self.Master.SwitchToWhileSearch(QueryString)
		if self.Autosyn.get()==1:
			QueryString=self.CreateAutoSyn(QueryString)
			
		self.Master.lstQuery=self.CreateQueryList(self.GetQueryTokens(QueryString))
		
		if not self.Master.TaxoObject.doInternetSearch(QueryString, self.Master.lstQuery):
			print '\nResultReciever: Sorry, no results returned from google...'
			#return to search mode
			self.Master.WhileSearchFrame.NoResults()
		else:
			self.Master.lstRelevantWords=self.Master.TaxoObject.lstRelevantWords
			for Word in self.Master.lstQuery:
				self.Master.dicQueryVector[Word]=0.1
			self.Master.SwitchToResults()
		
	def CreateAutoSyn(self,strQuery):
		lstTemp=self.GetQueryTokens(strQuery)
		lstTempSyn=[]
		
		for Item in lstTemp:
			if not Item=="OR":
				if Item[0]=="+":
					lstTempSyn.append("~"+Item[1:])
				elif not Item[0]=="-" and not Item[0]=='"':
					lstTempSyn.append("~"+Item)
				else:
					lstTempSyn.append(Item)
			else:
				lstTempSyn.append(Item)
		return join(lstTempSyn," ")
		
		
	def InRange(self,Source, CharPos):
		reQuote=re.compile('\".*?\"')
		
		for m in reQuote.finditer(Source):
			posTuple=m.span()
			if CharPos in range(posTuple[0],posTuple[1]):
				return 1
				
	def GetQueryTokens(self, tmpString):
		SynString=""
		j=0
		
		for Char in tmpString:
			if Char==" ":
				if self.InRange(tmpString, j):
					SynString=SynString+Char
				else:
					SynString=SynString+str("%")	
			else:
				SynString=SynString+str(Char)
			j=j+1
		return SynString.split("%")
		
	def CreateQueryList(self, lstTokens):
		lstQuery=[]
		strPlainItem=""
		
		for Item in lstTokens:
			if not Item=="OR" or Item[0]=="-":
				strPlainItem=Item.replace("+", "") 			#remove exact conjunctor
				strPlainItem=strPlainItem.replace('"', "")	#remove quotes
				lstQuery.append(strPlainItem)
		return lstQuery
		
	def KeyRelease(self, event):
		if event.keycode==13:
			self.doSearch()
		else:
			#update WordnetFrame, display WordNet-Items
			self.Master.WordnetObject.CreateObjects(self.Master.WordnetObject.GetCurrentWord(event.widget.index(INSERT), event.widget.get()))
			self.Master.WordnetFrame.NounFrame.Update(self.Master.WordnetObject.lstNouns)
			self.Master.WordnetFrame.VerbFrame.Update(self.Master.WordnetObject.lstVerbs)
			self.Master.WordnetFrame.AdjFrame.Update(self.Master.WordnetObject.lstAdjectives)
			
############################## END OF CLASS SearchFrame #######################################			

############################## BEGIN OF CLASS PriorityFrame ###################################
#This class contains the priority slot for information retrieval on search results
#there are three types of slots: Very important, Important and Iess important
#these frames are inherited from class ImpFrame

class PriorityFrame(Frame):
	def __init__(self, master):
		self.Master=master
		Frame.__init__ (self, self.Master, width=1024, height=100, relief=RAISED, bd=1)
		self.place(relx=0.0, rely=0.0)
		self.VIFrame=ImpFrame(self, 150,5,1, "Very important")
		self.IFrame=ImpFrame(self, 300,5,0.75, "Important")
		self.LIFrame=ImpFrame(self, 450,5,0.5, "Less important")
		self.BackButton=Button(self, text='Back to search', font="Helvetica 10 bold", fg="blue", width=20, command=self.BackSearch)
		self.BackButton.place(x=620,y=5)
		
	def BackSearch(self):
		self.Master.SwitchToSearch(2)

############################## END OF CLASS PriorityFrame #####################################


############################## BEGIN OF CLASS ImpFrame #######################################
#This is a generic class for rendering a priority slot in PriorityFrame
#the main properties are set by the constructor

class ImpFrame(Frame):
	def __init__(self, master, xImpPos, yImpPos, ItemWeight, Label):
		self.Master=master
		self.yPos=18
		self.LINESPACER=12
		self.COLSPACER=5
		self.ItemWeight=ItemWeight
		Frame.__init__ (self, self.Master, width=130, height=90, relief=SUNKEN, bd=1)
		self.place(x=xImpPos,y=yImpPos)
		self.ImpCanvas=Canvas(self, width=110, height=90, bg="white")
		
		ScrollBar=Scrollbar(self, orient=VERTICAL, relief=SUNKEN)
		ScrollBar.config(command=self.ImpCanvas.yview)
		ScrollBar.place(x=110,y=2, height=86)
		self.ImpCanvas.config(yscrollcommand=ScrollBar.set)
		self.ImpCanvas.place(x=0,y=0)
		
		self.ImpCanvas.create_text(55, 10, text=Label, font="Helvetica 10 bold", fill="lightblue", tags="IMP", width=600)
	
	def HandCursor(self, event):
		self.ImpCanvas.config(cursor="hand2")

	def NormalCursor(self, event):
		self.ImpCanvas.config(cursor="")
			
	def AddItem(self, Item):
		self.ImpCanvas.create_text(self.COLSPACER, self.yPos, anchor="nw", text=Item, font="Helvetica 8 underline", fill="blue", tags=("IMP", "LINK"), width=600)
		self.yPos=self.yPos+self.LINESPACER
		self.ImpCanvas.config(scrollregion=(0,0,0,self.yPos))
		self.Master.Master.dicQueryVector[Item]=self.ItemWeight
		self.Master.Master.PageRanking()
		
		self.ImpCanvas.tag_bind("LINK","<Enter>",self.HandCursor)
		self.ImpCanvas.tag_bind("LINK","<Leave>",self.NormalCursor)
		self.ImpCanvas.tag_bind("LINK","<ButtonPress-1>",self.RemoveItem)
		
	def RemoveItem(self, event):
		lstItemText=[]
	
		del self.Master.Master.dicQueryVector[event.widget.itemcget (CURRENT, "text")]
		
		for Item in self.ImpCanvas.find_withtag("LINK"):
			if not self.ImpCanvas.itemcget(Item, "text")==event.widget.itemcget (CURRENT, "text"):
				lstItemText.append(self.ImpCanvas.itemcget(Item, "text"))
		
		self.ClearItems()
		
		self.yPos=18
		for ItemText in lstItemText:
			self.AddItem(ItemText)
			
		self.Master.Master.PageRanking()
				
	def ClearItems(self):
		for Element in self.ImpCanvas.find_withtag("LINK"):
			self.ImpCanvas.delete(Element)		
		
############################## END OF CLASS ImpFrame #######################################

############################## BEGIN OF CLASS ResultFrame ##################################
#This frame class holds the ranked results given by information retrieval module
#each rendered result is clickable

class ResultFrame(Frame):
	def __init__(self, master):
		self.Master=master
		self.ySTART=10
		self.COLSPACER=15
		self.XOFFSET=10
		self.LINESPACER=12
		self.BLOCKSPACER=25
		self.xBAR=700
		Frame.__init__ (self, self.Master, width=824, height=585, relief=RAISED, bd=1)
		self.place(x=0, y=100)
		
		self.ResultCanvas=Canvas(self, width=800, height=540, bg="white")
		ScrollBar=Scrollbar(self, orient=VERTICAL, relief=SUNKEN)
		ScrollBar.config(command=self.ResultCanvas.yview)
		ScrollBar.place(x=803,y=2, height=536)
		self.ResultCanvas.config(yscrollcommand=ScrollBar.set)
		self.ResultCanvas.place(x=0,y=0)
	
	def DrawSimBar(self, yPos, Similarity):
		DrawWidth=int((Similarity*100)*0.6)
	
		self.ResultCanvas.create_rectangle(self.xBAR,yPos,self.xBAR+60,yPos+4, fill="lightblue", outline="lightblue", tags="RES")
		self.ResultCanvas.create_rectangle(self.xBAR,yPos,self.xBAR+DrawWidth,yPos+4, fill="blue", outline="blue", tags="RES")
		strProcent=str(int(Similarity*100))+"%"
		self.ResultCanvas.create_text(self.xBAR+65, yPos-3, anchor="nw", text=strProcent, font="Helvetica 7", fill="blue", tags="RES")
		
	def HandCursor(self, event):
		self.ResultCanvas.config(cursor="hand2")

	def NormalCursor(self, event):
		self.ResultCanvas.config(cursor="")
	
	def Open(self, event):
		webbrowser.open(event.widget.itemcget (CURRENT, "text"))
	
	def Update(self, lstResultSet):
		yPos=self.ySTART
		self.ClearItems()
		
		for item in lstResultSet:
			self.ResultCanvas.create_text(self.COLSPACER, yPos, anchor="nw", text=item[1].Title, font="Helvetica 8 bold", fill="red", tags="RES", width=600)
			self.DrawSimBar(yPos,item[0])
			yPos=yPos+self.LINESPACER
			self.ResultCanvas.create_text(self.COLSPACER, yPos, anchor="nw", text=item[1].URL, font="Helvetica 8 underline", fill="blue", tags=("RES", "LINK"), width=600)
			yPos=yPos+self.BLOCKSPACER
		self.ResultCanvas.config(scrollregion=(0,0,0,yPos+self.BLOCKSPACER))
		self.ResultCanvas.tag_bind("LINK","<Enter>",self.HandCursor)
		self.ResultCanvas.tag_bind("LINK","<Leave>",self.NormalCursor)
		self.ResultCanvas.tag_bind("LINK","<ButtonPress-1>",self.Open)
		
	def ClearItems(self):
		for Element in self.ResultCanvas.find_withtag("RES"):
			self.ResultCanvas.delete(Element)

############################## END OF CLASS ResultFrame #######################################
				
############################## BEGIN OF CLASS RankingFrame ####################################
#This class renders the relevant nouns and verbs given by information retrieval module
#the display can be filtered by typing in word fragments into a special text entry
		
class RankingFrame(Frame):
	def __init__(self, master):
		self.Master=master
		self.lstWordsDisplayed=[]
		self.ImportanceMode=IntVar()
		self.LINESPACER=15
		self.BLOCKSPACER=25
		#do the graphics...
		Frame.__init__ (self, self.Master, width=200, height=685, relief=RAISED, bd=1, bg="lightgray")
		self.place(x=824, y=0)
		
		self.VIRadio=Radiobutton(self, text="Very important", font="Helvetica 10", variable=self.ImportanceMode, value=1, bg="lightgray")
		self.IRadio=Radiobutton(self, text="Important", font="Helvetica 10", variable=self.ImportanceMode, value=2, bg="lightgray")
		self.LIRadio=Radiobutton(self, text="Less important", font="Helvetica 10", variable=self.ImportanceMode, value=3, bg="lightgray")
		self.RankingEntry=Entry(self, width=28)
		
		#placement
		self.VIRadio.place(x=30, y=10)
		self.IRadio.place(x=30, y=40)
		self.LIRadio.place(x=30, y=70)
		self.RankingEntry.place(x=2, y=645)
		self.VIRadio.select()
		self.RankingEntry.focus()
		
		self.RankingCanvas=Canvas(self, width=173, height=540, bg="white")
		ScrollBar=Scrollbar(self, orient=VERTICAL, relief=SUNKEN)
		ScrollBar.config(command=self.RankingCanvas.yview)
		ScrollBar.place(x=176,y=102, height=536)
		self.RankingCanvas.config(yscrollcommand=ScrollBar.set)
		self.RankingCanvas.place(x=2,y=100)
		
		self.RankingEntry.bind("<KeyRelease>", self.FilterRelease)
		self.RankingCanvas.tag_bind("Clicktext","<Enter>",self.HandCursor)
		self.RankingCanvas.tag_bind("Clicktext","<Leave>",self.NormalCursor)
		self.RankingCanvas.tag_bind("Clicktext","<ButtonPress-1>",self.ItemClick)
		
		for Element in self.Master.lstRelevantWords:
			self.lstWordsDisplayed.append(Element[1])
		self.lstWordsDisplayed.sort()
		
		#HIER
	def HandCursor(self, event):
		self.RankingCanvas.config(cursor="hand2")

	def NormalCursor(self, event):
		self.RankingCanvas.config(cursor="")
		
	def FilterRelease(self, event):
		self.Update(self.RankingEntry.get())
		
	def ItemClick(self, event):
		if self.ImportanceMode.get()==1:
			self.Master.PriorityFrame.VIFrame.AddItem(event.widget.itemcget (CURRENT, "text"))
		elif self.ImportanceMode.get()==2:
			self.Master.PriorityFrame.IFrame.AddItem(event.widget.itemcget (CURRENT, "text"))
		elif self.ImportanceMode.get()==3:
			self.Master.PriorityFrame.LIFrame.AddItem(event.widget.itemcget (CURRENT, "text"))
		
	def ClearItems(self):
		for Element in self.RankingCanvas.find_withtag("REL"):
			self.RankingCanvas.delete(Element)
		
	def Update(self, FilterString):
		yPos=10
		self.ClearItems()
			
		if not FilterString=="":
			lstTmpWordsDisplayed=filter(lambda Word: Word[0:len(FilterString)]==FilterString, self.lstWordsDisplayed)
		else:
			lstTmpWordsDisplayed=self.lstWordsDisplayed
		
		for Word in lstTmpWordsDisplayed:
			RankingText=self.RankingCanvas.create_text(5,yPos, anchor="nw", text=Word, font="Helvetica 8 underline",fill="blue", tags=("REL", "Clicktext"))
			yPos=yPos+self.LINESPACER
		self.RankingCanvas.config(scrollregion=(0,0,0,yPos+self.BLOCKSPACER))
		
############################## END OF CLASS RankingFrame #######################################	

############################## BEGIN OF CLASS WordnetFrame #####################################
#This is a container class for three POS frames: Nouns, Verbs and Adjectives
#it also supports a google conform conjunction mode for adding items to SeachFrame

class WordnetFrame(Frame):
	def __init__(self, master):
		self.Master=master
		self.ConjunctMode=IntVar()
		self.dicConjunctors={1:" ", 2:" OR ", 3:" -", 4:" +"}
		
		Frame.__init__ (self, self.Master, width=1024, height=585, relief=RAISED, bd=1)
		self.place(x=0, y=100)
		
		#diplay conjunction mode radio buttons
		self.AndModeRadio=Radiobutton(self, text="AND", font="Helvetica 10", variable=self.ConjunctMode, value=1)
		self.AndModeRadio.select()
		self.OrModeRadio=Radiobutton(self, text="OR",  font="Helvetica 10", variable=self.ConjunctMode, value=2)
		self.NotModeRadio=Radiobutton(self, text="NOT",  font="Helvetica 10", variable=self.ConjunctMode, value=3)
		self.ExactModeRadio=Radiobutton(self, text="EXACT / FORCE",  font="Helvetica 10", variable=self.ConjunctMode, value=4)
		
		self.AndModeRadio.place(x=35, y=4)
		self.OrModeRadio.place(x=100,y=4)
		self.NotModeRadio.place(x=160,y=4)
		self.ExactModeRadio.place(x=220,y=4)
		
		#display POS frames (Noun/Verb/Adjective)
		self.NounFrame=POSFrame(self,40,30,"Nouns")
		self.VerbFrame=POSFrame(self,355,30,"Verbs")
		self.AdjFrame=POSFrame(self,670,30,"Adjectives")

############################## END OF CLASS WordnetFrame #######################################

############################## BEGIN OF CLASS POSFrame #########################################
#This class displays the semantic information given by wordnet interface module
#it renders all senses to a word typed into SearchFrame text entry
#This is an generic class and all necessary properties are set by the constructor

class POSFrame(Frame):
	def __init__(self, master, xPos,yPos,strCategory):
		self.Master=master
		self.strCategory=strCategory
		#position constants
		self.yOffset=45
		self.LINESPACER=12
		self.SMALLSPACER=5
		self.BLOCKSPACER=25
		self.COLSPACER=15
		self.WORDSPACER=6
		self.COLWIDTH=200
		self.MAXLENGTH=52
		Frame.__init__ (self, self.Master, width=310, height=540, relief=SUNKEN, bd=1)
		self.place(x=xPos, y=yPos)
		
		#set up canvas widget, which holds wordnet data, with scrollbar
		self.MainCanvas=Canvas(self, width=285, height=540, bg="white")
		ScrollBar=Scrollbar(self, orient=VERTICAL, relief=SUNKEN)
		ScrollBar.config(command=self.MainCanvas.yview)
		ScrollBar.place(x=288,y=2, height=536)
		self.MainCanvas.config(yscrollcommand=ScrollBar.set)
		self.MainCanvas.place(x=0,y=0)
		self.MainCanvas.create_text(142,10,text=self.strCategory, font="Helvetica 12 bold", fill="lightblue")
		
#some eventhandler for POSFrame class
	def HandCursor(self, event):
		self.MainCanvas.config(cursor="hand2")

	def NormalCursor(self, event):
		self.MainCanvas.config(cursor="")
	
	def AddItem(self, event):
		QueryString=self.Master.Master.SearchFrame.QueryEntry.get()
		AddString=event.widget.itemcget (CURRENT, "text")
		#check if collocation
		if AddString.find(" ")>0:
			AddString='"' + AddString +'"'
		#update entry in search frame
		QueryString=QueryString.rstrip() + self.Master.dicConjunctors[self.Master.ConjunctMode.get()] + AddString
		self.Master.Master.SearchFrame.QueryEntry.delete(0,END)
		QueryString=self.Master.Master.SearchFrame.QueryEntry.insert(END,QueryString)

#Update procedure, called when searchframe changes		
	def Update(self, lstPOS):		
		Seperator=0
		xPos=0
		yPos=10
		
		self.ClearItems()
			
		for POSItem in lstPOS:
			#generate gloss for word
			Seperator=find(POSItem.gloss,";")
			if Seperator==-1:
				POSItemgloss=POSItem.gloss
			else:
				POSItemgloss=POSItem.gloss[0:Seperator]
			#print item header
			POSItemHeader=self.MainCanvas.create_text(10,yPos, anchor="nw", text=POSItem.form, font="Helvetica 8 bold", tags="POS", fill="red", width=270)
			yPos=yPos+self.LINESPACER
			
			#print item closs
			POSItemGlossText=self.MainCanvas.create_text(15,yPos, anchor="nw", text=POSItemgloss, font="Helvetica 8 italic", tags="POS", width=270)
			yPos=yPos+((len(POSItemgloss)/50+1)*self.LINESPACER)+self.SMALLSPACER
			
			#print synonyms
			yPos=self.RenderBonusItems("Synonyms", yPos, POSItem.lstSynonyms)
									
			#print Hypernyms
			yPos=self.RenderBonusItems("Hypernyms", yPos, POSItem.lstHypernyms)
									
			#print Hyponyms
			yPos=self.RenderBonusItems("Hyponyms", yPos, POSItem.lstHyponyms)
			yPos=yPos+self.BLOCKSPACER
			
		#do the bindings to event handler
		self.MainCanvas.config(scrollregion=(0,0,0,yPos+self.yOffset))
		self.MainCanvas.tag_bind("Clicktext","<Enter>",self.HandCursor)
		self.MainCanvas.tag_bind("Clicktext","<Leave>",self.NormalCursor)
		self.MainCanvas.tag_bind("Clicktext","<ButtonPress-1>",self.AddItem)
		
	def RenderBonusItems(self, Title, yPos, lstItems):
		Header=self.MainCanvas.create_text(10,yPos, anchor="nw", text=Title, font="Helvetica 8 bold", tags="POS", fill="blue", width=270)
		yPos=yPos+self.LINESPACER
			
		xPos=self.COLSPACER
		CurColumnWidth=0
		if len(lstItems)>0:
			for Item in lstItems:
				if CurColumnWidth+self.WORDSPACER+(len(Item))>self.COLWIDTH:
					CurColumnWidth=0
					xPos=self.COLSPACER
					yPos=yPos+self.LINESPACER
				
				ItemText=self.MainCanvas.create_text(xPos,yPos, anchor="nw", text=Item, font="Helvetica 8 underline",fill="blue", tags=("POS", "Clicktext"))
				CurColumnWidth=CurColumnWidth+self.WORDSPACER+(len(Item)*6)
				xPos=xPos+self.WORDSPACER+(len(Item)*6)
		else:
			xPos=self.COLSPACER
			ItemText=self.MainCanvas.create_text(xPos,yPos, anchor="nw", text="-none-", font="Helvetica 8 italic",fill="blue", tags="POS")
		yPos=yPos+self.LINESPACER+self.SMALLSPACER
		return yPos
	
	def ClearItems(self):
		for Element in self.MainCanvas.find_withtag("POS"):
			self.MainCanvas.delete(Element)

############################## END OF CLASS POSFrame #######################################

############################## BEGIN OF CLASS PseudoSearchFrame #############################
#This Frame class is displayed while performing google search and document processing
#the complete google query string is shown in this frame
#it substitutes the SearchFrame

class PseudoSearchFrame(Frame):
	def __init__(self, master, QueryString):
		self.Master=master
		Frame.__init__ (self, self.Master, width=1024, height=100, relief=RAISED, bd=1)
		self.place(relx=0.0, rely=0.0)
		HeaderLabel=Label(self, text="Performing google search with: ", font="Helvetica 16 bold", fg="blue")
		SearchLabel=Label(self, text=QueryString, font="Helvetica 16 italic", fg="blue")
		HeaderLabel.place(x=10,y=10)
		SearchLabel.place(x=10,y=40)
############################## END OF CLASS PseudoSearchFrameFrame #######################################		

############################## BEGIN OF CLASS WhileSearchFrame #######################################
#This Frame class is displayed while performing google search and document processing
#the stdout is piped into this frame to show the programm progress
#it substitutes the WordnetFrame

class WhileSearchFrame(Frame):
	def __init__(self, master):
		self.Master=master
		Frame.__init__ (self, self.Master, width=1024, height=585, relief=RAISED, bd=1)
		self.place(x=0, y=100)

		self.MessageCanvas=Canvas(self, width=996, height=575, bg="white", relief=SUNKEN)
		self.MessageCanvas.place(x=0,y=0)
		MessageText=self.MessageCanvas.create_text(10,10, anchor="nw", text="", font="Helvetica 8",fill="blue", tags="MESSAGE")
		
		self.MessageCanvas.tag_bind("NORESULTCLICK","<Enter>",self.HandCursor)
		self.MessageCanvas.tag_bind("NORESULTCLICK","<Leave>",self.NormalCursor)
		
	def HandCursor(self, event):
		self.MessageCanvas.config(cursor="hand2")

	def NormalCursor(self, event):
		self.MessageCanvas.config(cursor="")
		
	def write(self, message):
		msg=self.MessageCanvas.itemcget ("MESSAGE", "text")
		if (msg.count("\n")+1)>40:
			msg=""
		msg=msg+message
		self.MessageCanvas.itemconfigure("MESSAGE",text=msg)
		self.update_idletasks()
		
	def NoResults(self):
		MsgText=self.MessageCanvas.itemcget ("MESSAGE", "text")
		yPos=(MsgText.count("\n")+1)*16
		NoResultText=self.MessageCanvas.create_text(10,yPos, anchor="nw", text="Back to search", font="Helvetica 8 underline bold",fill="red", tags="NORESULTCLICK")
		self.MessageCanvas.tag_bind("NORESULTCLICK","<ButtonPress-1>",self.SwitchBack)
		
	def SwitchBack(self, event):
		self.Master.SwitchToSearch(1)

############################## END OF CLASS WhileSearchFrameFrame #######################################
			
root=Tk()
root.title ("TaxoSearch")
App=MainFrame(root)
root.mainloop()