eruta/zori/event/event.go

/* event handler and events for the Zori module. */

package event

import . "gitlab.com/beoran/ebsgo/zori/types"


type Basic struct {
    Stamp  float64
    // Widget Widget
    Data   interface{}
}

func (be Basic) Timestamp() float64 {
    return be.Stamp
}

/* Update event, when UI has to update (animations, etc). */
type Update struct {
    Basic
    TimePassed float64
}

/* Resize event, when the parent of an element has resized. */
type Resize struct {
    Basic
    NewSize Box
}

/* Draw event when the UI has to draw itself. */
type Draw struct {
    Basic
}

/* Cleanup event. */
type Destroy struct {
    Basic
}

/* Action event. */
type Action struct {
    Basic
}

/* Close event. */
type Close struct {
    Basic
    // Parent Widget
}

/* Close event. */
type NewChild struct {
    Basic
    // Child Widget
}

type Event interface {
    Timestamp() float64
}

type JoyButtonPress interface {
    ID() int
    Button() int
    IsJoyButtonPress()
}

type JoyButtonRelease interface {
    ID() int
    Button() int
    IsJoyButtonRelease()
}

type JoyAxis interface {
    Event
    ID() int
    Stick() int
    Axis() int
    Pos() float32
    IsJoyAxis()
}

type KeyPress interface {
    Event
    KeyCode() int
    Display() Display
    IsKeyPress()
}

type KeyRelease interface {
    Event
    KeyCode() int
    Display() Display
    IsKeyRelease()
}

type KeyChar interface {
    Event
    KeyCode() int
    Display() Display
    Unichar() rune
    Modifiers() int
    Repeat() bool
    IsKeyChar()
}

type MouseAxes interface {
    Event
    Display() Display
    X() int
    Y() int
    Z() int
    W() int
    DX() int
    DY() int
    DZ() int
    DW() int
    Pressure() float32
}

type MouseWarped interface {
    Event
    Display() Display
    X() int
    Y() int
    Z() int
    W() int
    DX() int
    DY() int
    DZ() int
    DW() int
    Pressure() float32
}

type MouseButtonPress interface {
    Event
    Display() Display
    X() int
    Y() int
    Z() int
    W() int
    Button() int
    Pressure() float32
}

type MouseButtonRelease interface {
    Event
    Display() Display
    X() int
    Y() int
    Z() int
    W() int
    Button() int
    Pressure() float32
}

type MouseEnterDisplay interface {
    Event
    Display() Display
    X() int
    Y() int
    Z() int
    W() int
}

type MouseLeaveDisplay interface {
    Event
    Display() Display
    X() int
    Y() int
    Z() int
    W() int
}


type Touch interface {
    Event
    Display() Display
    X() int
    Y() int
    DX() int
    DY() int
    ID() int
    Primary() bool
}

type TouchBegin interface {
    Touch
}


type TouchEnd interface {
    Touch
}

type TouchMove interface {
    Touch
}

type TouchCancel interface {
    Touch
}


type Result bool

type UIHandler interface {
    Update(ev Update) Result
    Resize(ev Resize) Result
    Draw(ev Draw) Result    
    Destroy(ev Destroy) Result
    Action(ev Action) Result
    Close(ev Close) Result
    NewChild(ev NewChild) Result
}

type JoyHandler interface {
    JoyButtonPress(ev JoyButtonPress) Result
    JoyButtonRelease(ev JoyButtonRelease) Result
    JoyAxis(ev JoyAxis) Result
}

type KeyHandler interface {
    KeyPress(ev KeyPress) Result
    KeyRelease(ev KeyRelease) Result
    KeyChar(ev KeyChar) Result
}

type MouseHandler interface {
    MouseAxes(ev MouseAxes) Result
    MouseWarped(ev MouseWarped) Result
    MouseButtonPress(ev MouseButtonPress) Result
    MouseButtonRelease(ev MouseButtonRelease) Result
    MouseEnterDisplay(ev MouseEnterDisplay) Result
    MouseLeaveDisplay(ev MouseLeaveDisplay) Result
}

type TouchHandler interface {
    TouchBegin(ev TouchBegin) Result
    TouchEnd(ev TouchEnd) Result
    TouchMove(ev TouchMove) Result
    TouchCancel(ev TouchCancel) Result    
}


/* Handler is an interface for a type that can handle all 
 * of Zori's events. */
type Handler interface {
    UIHandler
    JoyHandler
    KeyHandler
    MouseHandler
    TouchHandler
    Default(ev Event) Result
}


func Dispatch(event Event, handler Handler) Result {
    switch de := event.(type) {
    case Update:             return handler.Update(de)
    case Draw:               return handler.Draw(de)
    case Destroy:            return handler.Destroy(de)
    case Action:             return handler.Action(de)
    case Close:              return handler.Close(de)
    case NewChild:           return handler.NewChild(de)
    case JoyButtonPress:     return handler.JoyButtonPress(de)
    case JoyButtonRelease:   return handler.JoyButtonRelease(de)
    case JoyAxis:            return handler.JoyAxis(de)
    case KeyPress:           return handler.KeyPress(de)
    case KeyRelease:         return handler.KeyRelease(de)
    case KeyChar:            return handler.KeyChar(de)
    case MouseAxes:          return handler.MouseAxes(de)
    case MouseWarped:        return handler.MouseWarped(de)
    case MouseButtonPress:   return handler.MouseButtonPress(de)
    case MouseButtonRelease: return handler.MouseButtonRelease(de)
    case MouseEnterDisplay:  return handler.MouseEnterDisplay(de)
    case MouseLeaveDisplay:  return handler.MouseLeaveDisplay(de)
    case TouchBegin:         return handler.TouchBegin(de)
    case TouchEnd:           return handler.TouchEnd(de)
    case TouchMove:          return handler.TouchMove(de)
    case TouchCancel:        return handler.TouchCancel(de)            
    default:                 return handler.Default(event)
    }
}