*Event: Add Once method

11 files changed, 281 insertions, 90 deletions

diff --git a/cancelevent.go b/cancelevent.go
index a1502317..691db86f 100644
--- a/cancelevent.go
+++ b/cancelevent.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type cancelEventHandlerInfo struct {
+	handler CancelEventHandler
+	once    bool
+}
+
 type CancelEventHandler func(canceled *bool)
 
 type CancelEvent struct {
-	handlers []CancelEventHandler
+	handlers []cancelEventHandlerInfo
 }
 
 func (e *CancelEvent) Attach(handler CancelEventHandler) int {
+	handlerInfo := cancelEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *CancelEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *CancelEvent) Once(handler CancelEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type CancelEventPublisher struct {
@@ -37,9 +50,13 @@ func (p *CancelEventPublisher) Event() *CancelEvent {
 }
 
 func (p *CancelEventPublisher) Publish(canceled *bool) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(canceled)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(canceled)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/closeevent.go b/closeevent.go
index 284fc046..83dbcc0c 100644
--- a/closeevent.go
+++ b/closeevent.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type closeEventHandlerInfo struct {
+	handler CloseEventHandler
+	once    bool
+}
+
 type CloseEventHandler func(canceled *bool, reason CloseReason)
 
 type CloseEvent struct {
-	handlers []CloseEventHandler
+	handlers []closeEventHandlerInfo
 }
 
 func (e *CloseEvent) Attach(handler CloseEventHandler) int {
+	handlerInfo := closeEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *CloseEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *CloseEvent) Once(handler CloseEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type CloseEventPublisher struct {
@@ -37,9 +50,13 @@ func (p *CloseEventPublisher) Event() *CloseEvent {
 }
 
 func (p *CloseEventPublisher) Publish(canceled *bool, reason CloseReason) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(canceled, reason)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(canceled, reason)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/dropfilesevent.go b/dropfilesevent.go
index 1013bd33..22fd8ebe 100644
--- a/dropfilesevent.go
+++ b/dropfilesevent.go
@@ -7,42 +7,59 @@
 package walk
 
 import (
-	"github.com/lxn/win"
 	"syscall"
+
+	"github.com/lxn/win"
 )
 
+type dropFilesEventHandlerInfo struct {
+	handler DropFilesEventHandler
+	once    bool
+}
+
 type DropFilesEventHandler func([]string)
 
 type DropFilesEvent struct {
 	hWnd     win.HWND
-	handlers []DropFilesEventHandler
+	handlers []dropFilesEventHandlerInfo
 }
 
 func (e *DropFilesEvent) Attach(handler DropFilesEventHandler) int {
 	if len(e.handlers) == 0 {
 		win.DragAcceptFiles(e.hWnd, true)
 	}
+
+	handlerInfo := dropFilesEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *DropFilesEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+
 	for _, h := range e.handlers {
-		if h != nil {
+		if h.handler != nil {
 			return
 		}
 	}
+
 	win.DragAcceptFiles(e.hWnd, false)
 }
 
+func (e *DropFilesEvent) Once(handler DropFilesEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
+}
+
 type DropFilesEventPublisher struct {
 	event DropFilesEvent
 }
@@ -65,9 +82,13 @@ func (p *DropFilesEventPublisher) Publish(hDrop win.HDROP) {
 	}
 	win.DragFinish(hDrop)
 
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(files)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(files)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/errorevent.go b/errorevent.go
index 8481f7df..a5a69bcb 100644
--- a/errorevent.go
+++ b/errorevent.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type errorEventHandlerInfo struct {
+	handler ErrorEventHandler
+	once    bool
+}
+
 type ErrorEventHandler func(err error)
 
 type ErrorEvent struct {
-	handlers []ErrorEventHandler
+	handlers []errorEventHandlerInfo
 }
 
 func (e *ErrorEvent) Attach(handler ErrorEventHandler) int {
+	handlerInfo := errorEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *ErrorEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *ErrorEvent) Once(handler ErrorEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type ErrorEventPublisher struct {
@@ -37,9 +50,13 @@ func (p *ErrorEventPublisher) Event() *ErrorEvent {
 }
 
 func (p *ErrorEventPublisher) Publish(err error) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(err)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(err)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/event.go b/event.go
index ef94f936..15d7909b 100644
--- a/event.go
+++ b/event.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type eventHandlerInfo struct {
+	handler EventHandler
+	once    bool
+}
+
 type EventHandler func()
 
 type Event struct {
-	handlers []EventHandler
+	handlers []eventHandlerInfo
 }
 
 func (e *Event) Attach(handler EventHandler) int {
+	handlerInfo := eventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *Event) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *Event) Once(handler EventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type EventPublisher struct {
@@ -53,9 +66,13 @@ func (p *EventPublisher) Publish() {
 		}()
 	}
 
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler()
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler()
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/intevent.go b/intevent.go
index 8670d5b0..08161d6f 100644
--- a/intevent.go
+++ b/intevent.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type intEventHandlerInfo struct {
+	handler IntEventHandler
+	once    bool
+}
+
 type IntEventHandler func(n int)
 
 type IntEvent struct {
-	handlers []IntEventHandler
+	handlers []intEventHandlerInfo
 }
 
 func (e *IntEvent) Attach(handler IntEventHandler) int {
+	handlerInfo := intEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *IntEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *IntEvent) Once(handler IntEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type IntEventPublisher struct {
@@ -37,9 +50,13 @@ func (p *IntEventPublisher) Event() *IntEvent {
 }
 
 func (p *IntEventPublisher) Publish(n int) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(n)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(n)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/intrangeevent.go b/intrangeevent.go
index 042ecc4c..7b1d5422 100644
--- a/intrangeevent.go
+++ b/intrangeevent.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type intRangeEventHandlerInfo struct {
+	handler IntRangeEventHandler
+	once    bool
+}
+
 type IntRangeEventHandler func(from, to int)
 
 type IntRangeEvent struct {
-	handlers []IntRangeEventHandler
+	handlers []intRangeEventHandlerInfo
 }
 
 func (e *IntRangeEvent) Attach(handler IntRangeEventHandler) int {
+	handlerInfo := intRangeEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *IntRangeEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *IntRangeEvent) Once(handler IntRangeEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type IntRangeEventPublisher struct {
@@ -37,9 +50,13 @@ func (p *IntRangeEventPublisher) Event() *IntRangeEvent {
 }
 
 func (p *IntRangeEventPublisher) Publish(from, to int) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(from, to)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(from, to)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/keyevent.go b/keyevent.go
index 943dd2cc..f53a4825 100644
--- a/keyevent.go
+++ b/keyevent.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type keyEventHandlerInfo struct {
+	handler KeyEventHandler
+	once    bool
+}
+
 type KeyEventHandler func(key Key)
 
 type KeyEvent struct {
-	handlers []KeyEventHandler
+	handlers []keyEventHandlerInfo
 }
 
 func (e *KeyEvent) Attach(handler KeyEventHandler) int {
+	handlerInfo := keyEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *KeyEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *KeyEvent) Once(handler KeyEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type KeyEventPublisher struct {
@@ -37,9 +50,13 @@ func (p *KeyEventPublisher) Event() *KeyEvent {
 }
 
 func (p *KeyEventPublisher) Publish(key Key) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(key)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(key)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/mouseevent.go b/mouseevent.go
index 167f7084..81ab1e56 100644
--- a/mouseevent.go
+++ b/mouseevent.go
@@ -18,27 +18,40 @@ const (
 	MiddleButton MouseButton = win.MK_MBUTTON
 )
 
+type mouseEventHandlerInfo struct {
+	handler MouseEventHandler
+	once    bool
+}
+
 // MouseEventHandler is called for mouse events. x and y are measured in native pixels.
 type MouseEventHandler func(x, y int, button MouseButton)
 
 type MouseEvent struct {
-	handlers []MouseEventHandler
+	handlers []mouseEventHandlerInfo
 }
 
 func (e *MouseEvent) Attach(handler MouseEventHandler) int {
+	handlerInfo := mouseEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *MouseEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *MouseEvent) Once(handler MouseEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type MouseEventPublisher struct {
@@ -51,9 +64,13 @@ func (p *MouseEventPublisher) Event() *MouseEvent {
 
 // Publish publishes mouse event. x and y are measured in native pixels.
 func (p *MouseEventPublisher) Publish(x, y int, button MouseButton) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(x, y, button)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(x, y, button)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/stringevent.go b/stringevent.go
index a09d8c86..6c13a29f 100644
--- a/stringevent.go
+++ b/stringevent.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type stringEventHandlerInfo struct {
+	handler StringEventHandler
+	once    bool
+}
+
 type StringEventHandler func(s string)
 
 type StringEvent struct {
-	handlers []StringEventHandler
+	handlers []stringEventHandlerInfo
 }
 
 func (e *StringEvent) Attach(handler StringEventHandler) int {
+	handlerInfo := stringEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *StringEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *StringEvent) Once(handler StringEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type StringEventPublisher struct {
@@ -37,9 +50,13 @@ func (p *StringEventPublisher) Event() *StringEvent {
 }
 
 func (p *StringEventPublisher) Publish(s string) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(s)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(s)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }
diff --git a/treeitemevent.go b/treeitemevent.go
index ef2a320e..982e0f4e 100644
--- a/treeitemevent.go
+++ b/treeitemevent.go
@@ -6,26 +6,39 @@
 
 package walk
 
+type treeItemEventHandlerInfo struct {
+	handler TreeItemEventHandler
+	once    bool
+}
+
 type TreeItemEventHandler func(item TreeItem)
 
 type TreeItemEvent struct {
-	handlers []TreeItemEventHandler
+	handlers []treeItemEventHandlerInfo
 }
 
 func (e *TreeItemEvent) Attach(handler TreeItemEventHandler) int {
+	handlerInfo := treeItemEventHandlerInfo{handler, false}
+
 	for i, h := range e.handlers {
-		if h == nil {
-			e.handlers[i] = handler
+		if h.handler == nil {
+			e.handlers[i] = handlerInfo
 			return i
 		}
 	}
 
-	e.handlers = append(e.handlers, handler)
+	e.handlers = append(e.handlers, handlerInfo)
+
 	return len(e.handlers) - 1
 }
 
 func (e *TreeItemEvent) Detach(handle int) {
-	e.handlers[handle] = nil
+	e.handlers[handle].handler = nil
+}
+
+func (e *TreeItemEvent) Once(handler TreeItemEventHandler) {
+	i := e.Attach(handler)
+	e.handlers[i].once = true
 }
 
 type TreeItemEventPublisher struct {
@@ -37,9 +50,13 @@ func (p *TreeItemEventPublisher) Event() *TreeItemEvent {
 }
 
 func (p *TreeItemEventPublisher) Publish(item TreeItem) {
-	for _, handler := range p.event.handlers {
-		if handler != nil {
-			handler(item)
+	for i, h := range p.event.handlers {
+		if h.handler != nil {
+			h.handler(item)
+
+			if h.once {
+				p.event.Detach(i)
+			}
 		}
 	}
 }