import W
import Wapplication

import WASTEconst
import waste
import FrameWork

import Res
import Fm
import Menu

# Style and size menu. Note that style order is important (tied to bit values)
STYLES = [
	("Bold", "B"), ("Italic", "I"), ("Underline", "U"), ("Outline", "O"),
	("Shadow", ""), ("Condensed", ""), ("Extended", "")
	]
SIZES = [ 9, 10, 12, 14, 18, 24]

class StyledEditor(W.TextEditor):
	
	def __init__(self, possize, text = "", styles = None, soup = None, callback=None, wrap=1,
				inset=(4, 4), fontsettings=None, tabsettings=(32, 0), readonly=0):
		W.TextEditor.__init__(self, possize, text = "", callback=None, wrap=1,
				inset=(4, 4), fontsettings=None, tabsettings=(32, 0), readonly=0)
		self.tempstyles = styles
		self.tempsoup = soup
	
	def open(self):
		if not hasattr(self._parent, "_barx"):
			self._parent._barx = None
		if not hasattr(self._parent, "_bary"):
			self._parent._bary = None
		self._calcbounds()
		self.SetPort()
		viewrect, destrect = self._calctextbounds()
		flags = self._getflags()
		self.ted = waste.WENew(destrect, viewrect, flags)
		self.ted.WEInstallTabHooks()
		self.setfontsettings(self.fontsettings)
		self.settabsettings(self.tabsettings)
		self.ted.WEInsert(self.temptext, self.tempstyles, self.tempsoup)
		self.ted.WECalText()
		self.ted.WEResetModCount()
		if self.selection:
			self.setselection(self.selection[0], self.selection[1])
			self.selection = None
		else:
			self.selview()
		self.temptext = None
		self.tempstyles = None
		self.tempsoup = None
		self.updatescrollbars()
		self.bind("pageup", self.scrollpageup)
		self.bind("pagedown", self.scrollpagedown)
		self.bind("top", self.scrolltop)
		self.bind("bottom", self.scrollbottom)
		self.selchanged = 0
	
	def close(self):
		self.tempstyles = None
		self.tempsoup = None
		W.TextEditor.close(self)
	
	def set(self, text, style=None, soup=None):
		if not self.ted:
			self.temptext = text
			self.tempstyles = style
			self.tempsoup = soup
		else:
			texthandle = Res.Resource(text)
			self.ted.WESetSelection(0, self.tedWEGetTextLength())
			self.ted.WEDelete()
			self.ted.WEInsert(text, style, soup)
			self.ted.WESetSelection(0,0)
			self.ted.WECalText()
			self.SetPort()
			viewrect, destrect = self._calctextbounds()
			self.ted.WESetViewRect(viewrect)
			self.ted.WESetDestRect(destrect)
			rgn = Qd.NewRgn()
			Qd.RectRgn(rgn, viewrect)
			Qd.EraseRect(viewrect)
			self.draw(rgn)
			self.updatescrollbars()
	
	def get(self):
		if not self.ted:
			return self.temptext, self.tempstyles, self.tempsoup
		else:
			texthandle = Res.Resource('')
			styles = Res.Resource('')
			soup = Res.Resource('')
			self.ted.WECopyRange(0, self.tedWEGetTextLength(), texthandle, styles, soup)
			return text.data, styles, soup
	
	def settext(self, text):
		return W.TextEditor.set(self, text)
	
	def gettext(self):
		return W.TextEditor.get(self)
	
	def setstyle(self, which, towhat):
		self.ted.WESelView()
		self.ted.WESetStyle(which, towhat)
	
	def domenu_setfont(self, id, item, window, event):
		text = Menu.GetMenuHandle(id).GetMenuItemText(item)
		font = W.GetFNum(text)
		self.setstyle(WASTEconst.weDoFont, (font, 0, 0, (0, 0, 0)))
	
	def can_setfont(self, item):
		any, mode, (font, face, size, color) = self.ted.WEContinuousStyle(WASTEconst.weDoFont)
		if any and Fm.GetFontName(font) == item.menu.items[item.item-1][0]:
			item.check(1)
		else:
			item.check(0)
		return 1
	
	def domenu_setface(self, id, item, window, event):
		#title, shortcut, callback, kind = W.getapplication().menubar.menus[id].items[item-1]
		face = (1 << (item-1))
		self.setstyle(WASTEconst.weDoFace | WASTEconst.weDoToggleFace,
				(0, face, 0, (0, 0, 0)))
	
	def can_setface(self, item):
		any, mode, (font, face, size, color) = self.ted.WEContinuousStyle(WASTEconst.weDoFace)
		if any and item.menu.items[item.item-1][0] in getfaces(face):
			item.check(1)
		else:
			item.check(0)
		return 1
		
	def domenu_setsize(self, id, item, window, event):
		title, shortcut, callback, kind = W.getapplication().menubar.menus[id].items[item-1]
		size = title
		self.setstyle(WASTEconst.weDoSize,
				(0, 0, int(size), (0, 0, 0)))
	
	def can_setsize(self, item):
		any, mode, (font, face, size, color) = self.ted.WEContinuousStyle(WASTEconst.weDoSize)
		if any and item.menu.items[item.item-1][0] == str(size):
			item.check(1)
		else:
			item.check(0)
		return 1
	
	
	#def getfontsettings(self):
	#	pass
	#
	#def setfontsettings(self):
	#	pass
	
	def _getflags(self):
		flags = WASTEconst.weDoAutoScroll | WASTEconst.weDoOutlineHilite | WASTEconst.weDoDragAndDrop
		if self.readonly:
			flags = flags | WASTEconst.weDoReadOnly
		else:
			flags = flags | WASTEconst.weDoUndo
		return flags

def MakeFontMenu(menubar, where = 0):
	app = W.getapplication()
	fontmenu = Wapplication.Menu(menubar, "Font", where)
	for font in getfontnames():
		item = FrameWork.MenuItem(fontmenu, font, "", "setfont")
		app._menustocheck.append(item)
	return fontmenu

def MakeFaceMenu(menubar, where = 0):
	app = W.getapplication()
	facemenu = Wapplication.Menu(menubar, "Style", where)
	for face, key in STYLES:
		item = FrameWork.MenuItem(facemenu, face, key, "setface")
		app._menustocheck.append(item)
	return facemenu

def MakeSizeMenu(menubar, where=0):
	app = W.getapplication()
	sizemenu = Wapplication.Menu(menubar, "Size", where)
	for size in SIZES:
		item = FrameWork.MenuItem(sizemenu, str(size), "", "setsize")
		app._menustocheck.append(item)
	return sizemenu

def MakeNewMenus():
	mbar = W.getapplication().menubar
	MakeFontMenu(mbar)
	MakeFaceMenu(mbar)
	MakeSizeMenu(mbar)

def getfontnames():
	fontnames = []
	for i in range(1, Res.CountResources('FOND') + 1):
		r = Res.GetIndResource('FOND', i)
		name = r.GetResInfo()[2]
		if name[0] not in [".", "%"]:
			fontnames.append(name)
	fontnames.sort()
	return fontnames
	
def getfaces(face):
	faces = []
	for i in range(len(STYLES)):
		if face & (1 << i):
			faces.append(STYLES[i][0])
	return faces
			

if __name__ == "__main__":
	
	w = W.Window((600,400), "Styled Text", minsize = (150,150))

	w.text = StyledEditor((0,0,-16,0))
	w._bary = W.Scrollbar((-15, 0, 16, -14), w.text.vscroll, max = 32767)
	
	w.open()