now is go gettable and updated make file

cmd/micro/eventhandler.go

@@ -0,0 +1,196 @@
+package main
+
+import (
+	"time"
+)
+
+const (
+	// Opposite and undoing events must have opposite values
+
+	// TextEventInsert repreasents an insertion event
+	TextEventInsert = 1
+	// TextEventRemove represents a deletion event
+	TextEventRemove = -1
+)
+
+// TextEvent holds data for a manipulation on some text that can be undone
+type TextEvent struct {
+	c Cursor
+
+	eventType int
+	text      string
+	start     int
+	end       int
+	buf       *Buffer
+	time      time.Time
+}
+
+// ExecuteTextEvent runs a text event
+func ExecuteTextEvent(t *TextEvent) {
+	if t.eventType == TextEventInsert {
+		t.buf.Insert(t.start, t.text)
+	} else if t.eventType == TextEventRemove {
+		t.text = t.buf.Remove(t.start, t.end)
+	}
+}
+
+// UndoTextEvent undoes a text event
+func UndoTextEvent(t *TextEvent) {
+	t.eventType = -t.eventType
+	ExecuteTextEvent(t)
+}
+
+// EventHandler executes text manipulations and allows undoing and redoing
+type EventHandler struct {
+	v    *View
+	undo *Stack
+	redo *Stack
+}
+
+// NewEventHandler returns a new EventHandler
+func NewEventHandler(v *View) *EventHandler {
+	eh := new(EventHandler)
+	eh.undo = new(Stack)
+	eh.redo = new(Stack)
+	eh.v = v
+	return eh
+}
+
+// Insert creates an insert text event and executes it
+func (eh *EventHandler) Insert(start int, text string) {
+	e := &TextEvent{
+		c:         eh.v.cursor,
+		eventType: TextEventInsert,
+		text:      text,
+		start:     start,
+		end:       start + Count(text),
+		buf:       eh.v.buf,
+		time:      time.Now(),
+	}
+	eh.Execute(e)
+}
+
+// Remove creates a remove text event and executes it
+func (eh *EventHandler) Remove(start, end int) {
+	e := &TextEvent{
+		c:         eh.v.cursor,
+		eventType: TextEventRemove,
+		start:     start,
+		end:       end,
+		buf:       eh.v.buf,
+		time:      time.Now(),
+	}
+	eh.Execute(e)
+}
+
+// Replace deletes from start to end and replaces it with the given string
+func (eh *EventHandler) Replace(start, end int, replace string) {
+	eh.Remove(start, end)
+	eh.Insert(start, replace)
+}
+
+// Execute a textevent and add it to the undo stack
+func (eh *EventHandler) Execute(t *TextEvent) {
+	if eh.redo.Len() > 0 {
+		eh.redo = new(Stack)
+	}
+	eh.undo.Push(t)
+	ExecuteTextEvent(t)
+}
+
+// Undo the first event in the undo stack
+func (eh *EventHandler) Undo() {
+	t := eh.undo.Peek()
+	if t == nil {
+		return
+	}
+
+	te := t.(*TextEvent)
+	startTime := t.(*TextEvent).time.UnixNano() / int64(time.Millisecond)
+
+	eh.UndoOneEvent()
+
+	for {
+		t = eh.undo.Peek()
+		if t == nil {
+			return
+		}
+
+		te = t.(*TextEvent)
+
+		if startTime-(te.time.UnixNano()/int64(time.Millisecond)) > undoThreshold {
+			return
+		}
+
+		eh.UndoOneEvent()
+	}
+}
+
+// UndoOneEvent undoes one event
+func (eh *EventHandler) UndoOneEvent() {
+	// This event should be undone
+	// Pop it off the stack
+	t := eh.undo.Pop()
+	if t == nil {
+		return
+	}
+
+	te := t.(*TextEvent)
+	// Undo it
+	// Modifies the text event
+	UndoTextEvent(te)
+
+	// Set the cursor in the right place
+	teCursor := te.c
+	te.c = eh.v.cursor
+	eh.v.cursor = teCursor
+
+	// Push it to the redo stack
+	eh.redo.Push(te)
+}
+
+// Redo the first event in the redo stack
+func (eh *EventHandler) Redo() {
+	t := eh.redo.Peek()
+	if t == nil {
+		return
+	}
+
+	te := t.(*TextEvent)
+	startTime := t.(*TextEvent).time.UnixNano() / int64(time.Millisecond)
+
+	eh.RedoOneEvent()
+
+	for {
+		t = eh.redo.Peek()
+		if t == nil {
+			return
+		}
+
+		te = t.(*TextEvent)
+
+		if (te.time.UnixNano()/int64(time.Millisecond))-startTime > undoThreshold {
+			return
+		}
+
+		eh.RedoOneEvent()
+	}
+}
+
+// RedoOneEvent redoes one event
+func (eh *EventHandler) RedoOneEvent() {
+	t := eh.redo.Pop()
+	if t == nil {
+		return
+	}
+
+	te := t.(*TextEvent)
+	// Modifies the text event
+	UndoTextEvent(te)
+
+	teCursor := te.c
+	te.c = eh.v.cursor
+	eh.v.cursor = teCursor
+
+	eh.undo.Push(te)
+}