event: overhaul api

.gitignore

@@ -14,4 +14,7 @@
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
-coverage.txt
+coverage.txt
+
+# Workspace configuration
+.vscode

collision/attachSpace.go

@@ -19,27 +19,36 @@ type AttachSpace struct {
 	aSpace     **Space
 	tree       *Tree
 	offX, offY float64
+	binding    event.Binding
 }
 
 func (as *AttachSpace) getAttachSpace() *AttachSpace {
 	return as
 }
 
+func (as *AttachSpace) CID() event.CallerID {
+	return (*as.aSpace).CID
+}
+
+var _ attachSpace = &AttachSpace{}
+
 type attachSpace interface {
+	event.Caller
 	getAttachSpace() *AttachSpace
 }
 
 // Attach attaches v to the given space with optional x,y offsets. See AttachSpace.
 func Attach(v physics.Vector, s *Space, tree *Tree, offsets ...float64) error {
-	if t, ok := s.CID.E().(attachSpace); ok {
+	en := event.DefaultCallerMap.GetEntity(s.CID)
+	if t, ok := en.(attachSpace); ok {
 		as := t.getAttachSpace()
 		as.aSpace = &s
 		as.follow = v
 		as.tree = tree
 		if as.tree == nil {
 			as.tree = DefaultTree
 		}
-		s.CID.Bind(event.Enter, attachSpaceEnter)
+		as.binding = event.Bind(event.DefaultBus, event.Enter, t, attachSpaceEnter)
 		if len(offsets) > 0 {
 			as.offX = offsets[0]
 			if len(offsets) > 1 {
@@ -54,30 +63,19 @@ func Attach(v physics.Vector, s *Space, tree *Tree, offsets ...float64) error {
 // Detach removes the attachSpaceEnter binding from an entity composed with
 // AttachSpace
 func Detach(s *Space) error {
-	en := s.CID.E()
-	if _, ok := en.(attachSpace); ok {
-		event.UnbindBindable(
-			event.UnbindOption{
-				Event: event.Event{
-					Name:     event.Enter,
-					CallerID: s.CID,
-				},
-				Fn: attachSpaceEnter,
-			},
-		)
+	en := event.DefaultCallerMap.GetEntity(s.CID)
+	if as, ok := en.(attachSpace); ok {
+		as.getAttachSpace().binding.Unbind()
 		return nil
 	}
 	return errors.New("this space's entity is not composed of AttachSpace")
 }
 
-func attachSpaceEnter(id event.CID, _ interface{}) int {
-	as := id.E().(attachSpace).getAttachSpace()
+func attachSpaceEnter(asIface attachSpace, _ event.EnterPayload) event.Response {
+	as := asIface.(attachSpace).getAttachSpace()
 	x, y := as.follow.X()+as.offX, as.follow.Y()+as.offY
 	if x != (*as.aSpace).X() ||
 		y != (*as.aSpace).Y() {
-
-		// If this was a nil pointer it would have already crashed but as of release 2.2.0
-		// this could error from the space to delete not existing in the rtree.
 		as.tree.UpdateSpace(x, y, (*as.aSpace).GetW(), (*as.aSpace).GetH(), *as.aSpace)
 	}
 	return 0

collision/attachSpace_test.go

@@ -12,7 +12,7 @@ type aspace struct {
 	AttachSpace
 }
 
-func (as *aspace) Init() event.CID {
+func (as *aspace) Init() event.CallerID {
 	return event.NextID(as)
 }
 

collision/filter.go

@@ -43,7 +43,7 @@ func Without(tossFn func(*Space) bool) Filter {
 }
 
 // WithoutCIDs will return no spaces with a CID in the input
-func WithoutCIDs(cids ...event.CID) Filter {
+func WithoutCIDs(cids ...event.CallerID) Filter {
 	return Without(func(s *Space) bool {
 		for _, c := range cids {
 			if s.CID == c {

collision/onCollision.go

@@ -46,46 +46,43 @@ func PhaseCollisionWithBus(s *Space, tree *Tree, bus event.Handler, entities *ev
 		if oc.tree == nil {
 			oc.tree = DefaultTree
 		}
-		bus.Bind(event.Enter, s.CID, phaseCollisionEnter(entities))
+		bus.UnsafeBind(event.Enter.UnsafeEventID, s.CID, phaseCollisionEnter)
 		return nil
 	}
 	return errors.New("This space's entity does not implement collisionPhase")
 }
 
 // CollisionStart/Stop: when a PhaseCollision entity starts/stops touching some label.
-// Payload: (Label) the label the entity has started/stopped touching
-const (
-	Start = "CollisionStart"
-	Stop  = "CollisionStop"
+var (
+	Start = event.RegisterEvent[Label]()
+	Stop  = event.RegisterEvent[Label]()
 )
 
-func phaseCollisionEnter(entities *event.CallerMap) func(id event.CID, nothing interface{}) int {
-	return func(id event.CID, nothing interface{}) int {
-		e := entities.GetEntity(id).(collisionPhase)
-		oc := e.getCollisionPhase()
+func phaseCollisionEnter(id event.CallerID, handler event.Handler, _ interface{}) event.Response {
+	e := handler.GetCallerMap().GetEntity(id).(collisionPhase)
+	oc := e.getCollisionPhase()
 
-		// check hits
-		hits := oc.tree.Hits(oc.OnCollisionS)
-		newTouching := map[Label]bool{}
+	// check hits
+	hits := oc.tree.Hits(oc.OnCollisionS)
+	newTouching := map[Label]bool{}
 
-		// if any are new, trigger on collision
-		for _, h := range hits {
-			l := h.Label
-			if _, ok := oc.Touching[l]; !ok {
-				id.TriggerBus(Start, l, oc.bus)
-			}
-			newTouching[l] = true
+	// if any are new, trigger on collision
+	for _, h := range hits {
+		l := h.Label
+		if _, ok := oc.Touching[l]; !ok {
+			event.TriggerForCallerOn(oc.bus, id, Start, l)
 		}
+		newTouching[l] = true
+	}
 
-		// if we lost any, trigger off collision
-		for l := range oc.Touching {
-			if _, ok := newTouching[l]; !ok {
-				id.TriggerBus(Stop, l, oc.bus)
-			}
+	// if we lost any, trigger off collision
+	for l := range oc.Touching {
+		if _, ok := newTouching[l]; !ok {
+			event.TriggerForCallerOn(handler, id, Stop, l)
 		}
+	}
 
-		oc.Touching = newTouching
+	oc.Touching = newTouching
 
-		return 0
-	}
+	return 0
 }

collision/onCollision_test.go

@@ -12,7 +12,7 @@ type cphase struct {
 	callers *event.CallerMap
 }
 
-func (cp *cphase) Init() event.CID {
+func (cp *cphase) Init() event.CallerID {
 	return cp.callers.NextID(cp)
 }
 
@@ -37,11 +37,11 @@ func TestCollisionPhase(t *testing.T) {
 		t.Fatalf("phase collision failed: %v", err)
 	}
 	var active bool
-	bus.Bind("CollisionStart", cid, func(event.CID, interface{}) int {
+	bus.Bind("CollisionStart", cid, func(event.CallerID, interface{}) int {
 		active = true
 		return 0
 	})
-	bus.Bind("CollisionStop", cid, func(event.CID, interface{}) int {
+	bus.Bind("CollisionStop", cid, func(event.CallerID, interface{}) int {
 		active = false
 		return 0
 	})

collision/ray/castFilter.go

@@ -46,7 +46,7 @@ func IgnoreLabels(ls ...collision.Label) CastOption {
 }
 
 // AcceptIDs is equivalent to AcceptLabels, but for CIDs.
-func AcceptIDs(ids ...event.CID) CastOption {
+func AcceptIDs(ids ...event.CallerID) CastOption {
 	return AddFilter(func(s *collision.Space) bool {
 		for _, id := range ids {
 			if s.CID == id {
@@ -58,7 +58,7 @@ func AcceptIDs(ids ...event.CID) CastOption {
 }
 
 // IgnoreIDs is equivalent to IgnoreLabels, but for CIDs.
-func IgnoreIDs(ids ...event.CID) CastOption {
+func IgnoreIDs(ids ...event.CallerID) CastOption {
 	return AddFilter(func(s *collision.Space) bool {
 		for _, id := range ids {
 			if s.CID == id {

collision/ray/castLimit.go

@@ -47,7 +47,7 @@ func StopAtLabel(ls ...collision.Label) CastOption {
 
 // StopAtID will cause a caster to cease casting as soon as it
 // hits one of the input CIDs.
-func StopAtID(ids ...event.CID) CastOption {
+func StopAtID(ids ...event.CallerID) CastOption {
 	return AddLimit(func(ps []collision.Point) bool {
 		z := ps[len(ps)-1].Zone
 		for _, id := range ids {

collision/space.go

@@ -23,7 +23,7 @@ type Space struct {
 	Label Label
 	// A CID can be used to get the exact
 	// entity which this rectangle belongs to.
-	CID event.CID
+	CID event.CallerID
 	// Type represents which ID space the above ID
 	// corresponds to.
 	Type int
@@ -197,7 +197,7 @@ func NewUnassignedSpace(x, y, w, h float64) *Space {
 }
 
 // NewSpace returns a space with an associated caller id
-func NewSpace(x, y, w, h float64, cID event.CID) *Space {
+func NewSpace(x, y, w, h float64, cID event.CallerID) *Space {
 	return NewFullSpace(x, y, w, h, NilLabel, cID)
 }
 
@@ -212,7 +212,7 @@ func NewLabeledSpace(x, y, w, h float64, l Label) *Space {
 }
 
 // NewFullSpace returns a space with both a label and a caller id
-func NewFullSpace(x, y, w, h float64, l Label, cID event.CID) *Space {
+func NewFullSpace(x, y, w, h float64, l Label, cID event.CallerID) *Space {
 	rect := NewRect(x, y, w, h)
 	return &Space{
 		rect,
@@ -223,12 +223,12 @@ func NewFullSpace(x, y, w, h float64, l Label, cID event.CID) *Space {
 }
 
 // NewRect2Space returns a space with an associated caller id from a rect2
-func NewRect2Space(rect floatgeom.Rect2, cID event.CID) *Space {
+func NewRect2Space(rect floatgeom.Rect2, cID event.CallerID) *Space {
 	return NewSpace(rect.Min.X(), rect.Min.Y(), rect.W(), rect.H(), cID)
 }
 
 // NewRectSpace creates a colliison space with the specified 3D rectangle
-func NewRectSpace(rect floatgeom.Rect3, l Label, cID event.CID) *Space {
+func NewRectSpace(rect floatgeom.Rect3, l Label, cID event.CallerID) *Space {
 	return &Space{
 		rect,
 		l,

config.go

@@ -22,7 +22,6 @@ type Config struct {
 	IdleDrawFrameRate      int              `json:"idleDrawFrameRate"`
 	Language               string           `json:"language"`
 	Title                  string           `json:"title"`
-	EventRefreshRate       Duration         `json:"refreshRate"`
 	BatchLoad              bool             `json:"batchLoad"`
 	GestureSupport         bool             `json:"gestureSupport"`
 	LoadBuiltinCommands    bool             `json:"loadBuiltinCommands"`
@@ -98,7 +97,6 @@ func (c Config) setDefaults() Config {
 	c.IdleDrawFrameRate = 60
 	c.Language = "English"
 	c.Title = "Oak Window"
-	c.EventRefreshRate = Duration(50 * time.Millisecond)
 	return c
 }
 
@@ -223,9 +221,6 @@ func (c Config) overwriteFrom(c2 Config) Config {
 	if c2.Title != "" {
 		c.Title = c2.Title
 	}
-	if c2.EventRefreshRate != 0 {
-		c.EventRefreshRate = c2.EventRefreshRate
-	}
 	// Booleans can be directly overwritten-- all booleans in a Config
 	// default to false, if they were unset they will stay false.
 	c.BatchLoad = c2.BatchLoad

debugstream/scopeHelper.go

@@ -69,14 +69,13 @@ const explainMouseDetails = "the mext mouse click on the given window will print
 
 func mouseCommands(w window.Window) func([]string) string {
 	return func(tokenString []string) string {
-		w.EventHandler().GlobalBind("MouseRelease", mouseDetails(w))
+		event.GlobalBind(w.EventHandler(), mouse.Release, mouseDetails(w))
 		return ""
 	}
 }
 
-func mouseDetails(w window.Window) func(event.CID, interface{}) int {
-	return func(nothing event.CID, mevent interface{}) int {
-		me := mevent.(mouse.Event)
+func mouseDetails(w window.Window) func(*mouse.Event) event.Response {
+	return func(me *mouse.Event) event.Response {
 		viewPos := w.Viewport()
 		x := int(me.X()) + viewPos[0]
 		y := int(me.Y()) + viewPos[1]
@@ -86,17 +85,19 @@ func mouseDetails(w window.Window) func(event.CID, interface{}) int {
 		if len(results) == 0 {
 			results = mouse.Hits(loc)
 		}
+		cm := w.GetCallerMap()
+
 		if len(results) > 0 {
-			i := int(results[0].CID)
-			if i > 0 && event.HasEntity(event.CID(i)) {
-				e := event.GetEntity(event.CID(i))
+			i := results[0].CID
+			if i > 0 && cm.HasEntity(i) {
+				e := cm.GetEntity(i)
 				fmt.Printf("%+v\n", e)
 			} else {
 				fmt.Println("No entity ", i)
 			}
 		}
 
-		return event.UnbindSingle
+		return event.UnbindThis
 	}
 }