path: root/Mac/Demo/mlte/mlted.py

# A minimal text editor using MLTE. Based on wed.py.
#
# To be done:
# - Functionality: find, etc.

from Menu import DrawMenuBar
from FrameWork import *
from Carbon import Win
from Carbon import Ctl
from Carbon import Qd
from Carbon import Res
from Carbon import Scrap
import os
from Carbon import MacTextEditor
from Carbon import Mlte

UNDOLABELS = [ # Indexed by MLTECanUndo() value
	"Typing", "Cut", "Paste", "Clear", "Font Change", "Color Change", "Size Change",
	"Style Change", "Align Left", "Align Center", "Align Right", "Drop", "Move"]
	
class MlteWindow(Window):
	def open(self, path, name, data):
		self.path = path
		self.name = name
		r = windowbounds(400, 400)
		w = Win.NewWindow(r, name, 1, 0, -1, 1, 0)
		self.wid = w
		flags = MacTextEditor.kTXNDrawGrowIconMask|MacTextEditor.kTXNWantHScrollBarMask| \
				MacTextEditor.kTXNWantVScrollBarMask
		self.ted, self.frameid = Mlte.TXNNewObject(None, w, None, flags, MacTextEditor.kTXNTextEditStyleFrameType,
				MacTextEditor.kTXNTextFile, MacTextEditor.kTXNMacOSEncoding)
		self.ted.TXNSetData(MacTextEditor.kTXNTextData, data, 0, 0x7fffffff)
		self.changed = 0
		self.do_postopen()
		self.do_activate(1, None)
		
	def do_idle(self, event):
		self.ted.TXNIdle()	
		self.ted.TXNAdjustCursor(None)
		

		
	def do_activate(self, onoff, evt):
		if onoff:
##			self.ted.TXNActivate(self.frameid, 0)
			self.ted.TXNFocus(1)
			self.parent.active = self
		else:
			self.ted.TXNFocus(0)
			self.parent.active = None
		self.parent.updatemenubar()

	def do_update(self, wid, event):
		self.ted.TXNDraw(None)
		
	def do_postresize(self, width, height, window):
		self.ted.TXNResizeFrame(width, height, self.frameid)
		
	def do_contentclick(self, local, modifiers, evt):
		self.ted.TXNClick(evt)
		self.parent.updatemenubar()
		
	def do_char(self, ch, event):
		self.ted.TXNKeyDown(event)
		self.parent.updatemenubar()
		
	def close(self):
		if self.changed:
			save = EasyDialogs.AskYesNoCancel('Save window "%s" before closing?'%self.name, 1)
			if save > 0:
				self.menu_save()
			elif save < 0:
				return
		if self.parent.active == self:
			self.parent.active = None
		self.ted.TXNDeleteObject()
		del self.ted
##		del self.tedtexthandle
		self.do_postclose()
		
	def menu_save(self):
		if not self.path:
			self.menu_save_as()
			return # Will call us recursively
		dhandle = self.ted.TXNGetData(0, 0x7fffffff)
		data = dhandle.data
		fp = open(self.path, 'wb')  # NOTE: wb, because data has CR for end-of-line
		fp.write(data)
		if data[-1] <> '\r': fp.write('\r')
		fp.close()
		self.changed = 0
		
	def menu_save_as(self):
		path = EasyDialogs.AskFileForSave(message='Save as:')
		if not path: return
		self.path = path
		self.name = os.path.split(self.path)[-1]
		self.wid.SetWTitle(self.name)
		self.menu_save()
		
	def menu_cut(self):
##		self.ted.WESelView()
		self.ted.TXNCut()
###		Mlte.ConvertToPublicScrap()
##		Scrap.ZeroScrap()
##		self.ted.WECut()
##		self.updatescrollbars()
		self.parent.updatemenubar()
		self.changed = 1
		
	def menu_copy(self):
##		Scrap.ZeroScrap()
		self.ted.TXNCopy()
###		Mlte.ConvertToPublicScrap()
##		self.updatescrollbars()
		self.parent.updatemenubar()
		
	def menu_paste(self):
###		Mlte.ConvertFromPublicScrap()
		self.ted.TXNPaste()
##		self.updatescrollbars()
		self.parent.updatemenubar()
		self.changed = 1
		
	def menu_clear(self):
##		self.ted.WESelView()
		self.ted.TXNClear()
##		self.updatescrollbars()
		self.parent.updatemenubar()
		self.changed = 1

	def menu_undo(self):
		self.ted.TXNUndo()
##		self.updatescrollbars()
		self.parent.updatemenubar()
				
	def menu_redo(self):
		self.ted.TXNRedo()
##		self.updatescrollbars()
		self.parent.updatemenubar()
				
	def have_selection(self):
		start, stop = self.ted.TXNGetSelection()
		return start < stop
		
	def can_paste(self):
		return Mlte.TXNIsScrapPastable()
		
	def can_undo(self):
		can, which = self.ted.TXNCanUndo()
		if not can:
			return None
		if which >= len(UNDOLABELS):
			# Unspecified undo
			return "Undo"
		which = UNDOLABELS[which]
		
		return "Undo "+which

	def can_redo(self):
		can, which = self.ted.TXNCanRedo()
		if not can:
			return None
		if which >= len(UNDOLABELS):
			# Unspecified undo
			return "Redo"
		which = UNDOLABELS[which]
		
		return "Redo "+which

class Mlted(Application):
	def __init__(self):
		Application.__init__(self)
		self.num = 0
		self.active = None
		self.updatemenubar()
		
	def makeusermenus(self):
		self.filemenu = m = Menu(self.menubar, "File")
		self.newitem = MenuItem(m, "New window", "N", self.open)
		self.openitem = MenuItem(m, "Open...", "O", self.openfile)
		self.closeitem = MenuItem(m, "Close", "W", self.closewin)
		m.addseparator()
		self.saveitem = MenuItem(m, "Save", "S", self.save)
		self.saveasitem = MenuItem(m, "Save as...", "", self.saveas)
		m.addseparator()
		self.quititem = MenuItem(m, "Quit", "Q", self.quit)
		
		self.editmenu = m = Menu(self.menubar, "Edit")
		self.undoitem = MenuItem(m, "Undo", "Z", self.undo)
		self.redoitem = MenuItem(m, "Redo", None, self.redo)
		m.addseparator()
		self.cutitem = MenuItem(m, "Cut", "X", self.cut)
		self.copyitem = MenuItem(m, "Copy", "C", self.copy)
		self.pasteitem = MenuItem(m, "Paste", "V", self.paste)
		self.clearitem = MenuItem(m, "Clear", "", self.clear)
		
		# Groups of items enabled together:
		self.windowgroup = [self.closeitem, self.saveitem, self.saveasitem, self.editmenu]
		self.focusgroup = [self.cutitem, self.copyitem, self.clearitem]
		self.windowgroup_on = -1
		self.focusgroup_on = -1
		self.pastegroup_on = -1
		self.undo_label = "never"
		self.redo_label = "never"
		
	def updatemenubar(self):
		changed = 0
		on = (self.active <> None)
		if on <> self.windowgroup_on:
			for m in self.windowgroup:
				m.enable(on)
			self.windowgroup_on = on
			changed = 1
		if on:
			# only if we have an edit menu
			on = self.active.have_selection()
			if on <> self.focusgroup_on:
				for m in self.focusgroup:
					m.enable(on)
				self.focusgroup_on = on
				changed = 1
			on = self.active.can_paste()
			if on <> self.pastegroup_on:
				self.pasteitem.enable(on)
				self.pastegroup_on = on
				changed = 1
			on = self.active.can_undo()
			if on <> self.undo_label:
				if on:
					self.undoitem.enable(1)
					self.undoitem.settext(on)
					self.undo_label = on
				else:
					self.undoitem.settext("Nothing to undo")
					self.undoitem.enable(0)
				changed = 1
			on = self.active.can_redo()
			if on <> self.redo_label:
				if on:
					self.redoitem.enable(1)
					self.redoitem.settext(on)
					self.redo_label = on
				else:
					self.redoitem.settext("Nothing to redo")
					self.redoitem.enable(0)
				changed = 1
		if changed:
			DrawMenuBar()

	#
	# Apple menu
	#
	
	def do_about(self, id, item, window, event):
		EasyDialogs.Message("A simple single-font text editor based on MacTextEditor")
			
	#
	# File menu
	#

	def open(self, *args):
		self._open(0)
		
	def openfile(self, *args):
		self._open(1)

	def _open(self, askfile):
		if askfile:
			path = EasyDialogs.AskFileForOpen(typeList=('TEXT',))
			if not path:
				return
			name = os.path.split(path)[-1]
			try:
				fp = open(path, 'rb') # NOTE binary, we need cr as end-of-line
				data = fp.read()
				fp.close()
			except IOError, arg:
				EasyDialogs.Message("IOERROR: %r" % (arg,))
				return
		else:
			path = None
			name = "Untitled %d"%self.num
			data = ''
		w = MlteWindow(self)
		w.open(path, name, data)
		self.num = self.num + 1
		
	def closewin(self, *args):
		if self.active:
			self.active.close()
		else:
			EasyDialogs.Message("No active window?")
		
	def save(self, *args):
		if self.active:
			self.active.menu_save()
		else:
			EasyDialogs.Message("No active window?")
		
	def saveas(self, *args):
		if self.active:
			self.active.menu_save_as()
		else:
			EasyDialogs.Message("No active window?")
			
		
	def quit(self, *args):
		for w in self._windows.values():
			w.close()
		if self._windows:
			return
		self._quit()
		
	#
	# Edit menu
	#
	
	def undo(self, *args):
		if self.active:
			self.active.menu_undo()
		else:
			EasyDialogs.Message("No active window?")
		
	def redo(self, *args):
		if self.active:
			self.active.menu_redo()
		else:
			EasyDialogs.Message("No active window?")
		
	def cut(self, *args):
		if self.active:
			self.active.menu_cut()
		else:
			EasyDialogs.Message("No active window?")
		
	def copy(self, *args):
		if self.active:
			self.active.menu_copy()
		else:
			EasyDialogs.Message("No active window?")
		
	def paste(self, *args):
		if self.active:
			self.active.menu_paste()
		else:
			EasyDialogs.Message("No active window?")

	def clear(self, *args):
		if self.active:
			self.active.menu_clear()
		else:
			EasyDialogs.Message("No active window?")
		
	#
	# Other stuff
	#	

	def idle(self, event):
		if self.active:
			self.active.do_idle(event)
		else:
			Qd.SetCursor(Qd.GetQDGlobalsArrow())

def main():
	Mlte.TXNInitTextension(0)
	try:
		App = Mlted()
		App.mainloop()
	finally:
		Mlte.TXNTerminateTextension()
	
if __name__ == '__main__':
	main()