separate modifiers

package main

import (

	"fmt"

	"github.com/nsf/termbox-go"

	"github.com/simulatedsimian/joystick"

	"os"

	"strconv"

	"time"

)

func printAt(x, y int, s string) {

	for _, r := range s {

		termbox.SetCell(x, y, r, termbox.ColorDefault, termbox.ColorDefault)

		x++

	}

}

func readJoystick(js joystick.Joystick) {

	jinfo, err := js.Read()

	if err != nil {

		printAt(1, 5, "Error: "+err.Error())

		return

	}

	printAt(1, 5, "Buttons:")

	for button := 0; button < js.ButtonCount(); button++ {

		if jinfo.Buttons&(1<<uint32(button)) != 0 {

			printAt(10+button, 5, "X")

		} else {

			printAt(10+button, 5, ".")

		}

	}

	for axis := 0; axis < js.AxisCount(); axis++ {

		printAt(1, axis+7, fmt.Sprintf("Axis %2d Value: %7d", axis, jinfo.AxisData[axis]))

	}

	return

}

func main() {

	jsid := 0

	if len(os.Args) > 1 {

		i, err := strconv.Atoi(os.Args[1])

		if err != nil {

			fmt.Println(err)

			return

		}

		jsid = i

	}

	js, jserr := joystick.Open(jsid)

	if jserr != nil {

		fmt.Println(jserr)

		return

	}

	err := termbox.Init()

	if err != nil {

		panic(err)

	}

	defer termbox.Close()

	eventQueue := make(chan termbox.Event)

	go func() {

		for {

			eventQueue <- termbox.PollEvent()

		}

	}()

	ticker := time.NewTicker(time.Millisecond * 40)

	for doQuit := false; !doQuit; {

		select {

		case ev := <-eventQueue:

			if ev.Type == termbox.EventKey {

				if ev.Ch == 'q' {

					doQuit = true

				}

			}

			if ev.Type == termbox.EventResize {

				termbox.Flush()

			}

		case <-ticker.C:

			printAt(1, 0, "-- Press 'q' to Exit --")

			printAt(1, 1, fmt.Sprintf("Joystick Name: %s", js.Name()))

			printAt(1, 2, fmt.Sprintf("   Axis Count: %d", js.AxisCount()))

			printAt(1, 3, fmt.Sprintf(" Button Count: %d", js.ButtonCount()))

			readJoystick(js)

			termbox.Flush()

		}

	}

}

package main

import "github.com/splace/joysticks"

import "log"

import  "time"

type Region struct{

	minX,minY,maxX,maxY float32

}

type RegionEvent struct {

	time time.Duration

	Index int

}

func (b RegionEvent) Moment() time.Duration {

	return b.time

}

func OnRegionChanged(trigger,position chan joysticks.Event, regions []Region) (chan RegionEvent,chan RegionEvent){

	in := make(chan RegionEvent)

	out := make(chan RegionEvent)

	states:=make([]bool,len(regions))

	var pevt joysticks.CoordsEvent

	go func(){

		for e:=range(position){

			switch v := e.(type) {

			case joysticks.CoordsEvent:

				pevt=v

		    }

		}

	}()

	go func(){

		for e:=range(trigger){

			for ri,r:=range(regions){

				if pevt.X>=r.minX && pevt.X<=r.maxX && pevt.Y>=r.minY && pevt.Y<=r.maxY{ 

					if !states[ri]{

						in <-RegionEvent{e.Moment(),ri}

						states[ri]=true

					}

				}else{

					if states[ri]{

						out <-RegionEvent{e.Moment(),ri}

						states[ri]=false

					}

				}

			}

		}

		close(in)

		close(out)

	}()

	return in,out

}

func main() {

	device := joysticks.Connect(1)

	if device == nil {

		log.Println("no HIDs")

		return

	}

	log.Printf("HID#1:- Buttons:%d, Hats:%d\n", len(device.Buttons), len(device.HatAxes)/2)

	// make channels for specific events

	regionEntering,regionExiting:=OnRegionChanged(device.OnHat(1),device.OnMove(1),[]Region{Region{.5,.5,1,1},Region{-1,-1,-.5,-.5}})

	// feed OS events onto the event channels. 

	go device.ParcelOutEvents()

	// handle event channels

	go func(){

		for{

			select {

			case r:= <-regionEntering:

				log.Println("enter region:",r.Index)

			case r:= <-regionExiting:

				log.Println("leave region:",r.Index)

			}

		}

	}()

	log.Println("Timeout in 10 secs.")

	<-time.After(time.Second*10)

	log.Println("Shutting down due to timeout.")

}

package main

import (

	"io"

	"os/exec"

	"time"

	"math"

	"os"

	"os/signal"

	"log"

)

import . "github.com/splace/joysticks"

import . "github.com/splace/sounds"

func main() {

	stopChan := make(chan os.Signal)

	signal.Notify(stopChan, os.Interrupt)

	events := Capture(

		Channel{10, HID.OnLong},  // event[0] button #10 long pressed

		Channel{1, HID.OnClose},  // event[1] button #1 closes

		Channel{7, HID.OnOpen},  // event[2] button #7 opens

		Channel{8, HID.OnOpen},  // event[3] button #8 opens

		Channel{2, HID.OnRotate}, // event[4] hat #1 rotates

		Channel{1, HID.OnEdge}, // event[5] hat #2 rotates

	)

	var volume float32 = .5

	var octave =5

	var note int =1

	for {

		select {

		case <-stopChan: // wait for SIGINT

			log.Println("Interrupted")

			return

		case <-events[0]:

			return

		case <-events[1]:

			play(NewSound(NewTone(Period(octave,note), float64(volume)), time.Second/3))

		case <-events[2]:

			octave++

		case <-events[3]:

			octave--

		case h := <-events[4]:

			volume = h.(HatAngleEvent).Angle/6.28 + .5

		case h := <-events[5]:

			//f = time.Duration(100*math.Pow(2, float64(h.(HatAngleEvent).Angle)/6.28)) * time.Second / 44000

			note = int(h.(HatAngleEvent).Angle*6 / math.Pi)+6

			play(NewSound(NewTone(Period(octave,note), float64(volume)), time.Second/3))

		}

	}

}

func play(s Sound) {

	cmd := exec.Command("aplay")

	out, in := io.Pipe()

	go func() {

		Encode(in, 2, 44100, s)

		in.Close()

	}()

	cmd.Stdin = out

	err := cmd.Run()

	if err != nil {

		panic(err)

	}

	log.Println("Playing:",s)

}