Single select in main controls entire process

1 files changed, 28 insertions, 100 deletions

diff --git a/main.go b/main.go
index acc02b8..0a7951c 100644
--- a/main.go
+++ b/main.go
@@ -11,72 +11,6 @@ import (
 	"hhvn.uk/hbspbar/bar"
 )
 
-var reloadEvents = []string{
-	"monitor_rename",
-	"monitor_swap",
-	"monitor_focus",
-	"monitor_remove",
-	"monitor_geometry", // only event we get for monitors on restart
-	"desktop_add",
-	"desktop_rename",
-	"desktop_remove",
-	"desktop_swap",
-	"desktop_transfer",
-	"desktop_focus",
-	"desktop_activate",
-	"desktop_layout",
-	"node_add",
-	"node_remove",
-	"node_swap",
-	"node_transfer" }
-
-func reloadState(current *bspc.State) (*bspc.State, error) {
-	state, err := bspc.LoadState()
-
-	if err != nil {
-		return current, err
-	} else {
-		return state, nil
-	}
-}
-
-func handleEvents(events *bspc.Subscriber) (chan error, chan bool) {
-	var event *bspc.Event
-
-	errors := make(chan error)
-	reload := make(chan bool)
-
-	go func(){ for {
-		select {
-		case err := <-events.Err:
-			errors <- err
-			return
-		case event = <- events.Event:
-		}
-
-		if strings.HasPrefix(event.Name, "monitor_") {
-			id, err := common.Intify(event.Tokens[0])
-			if err == nil {
-				switch (event.Name) {
-				case "monitor_add":
-				case "monitor_geometry":
-					bar.Handle.Create <- id
-				case "monitor_remove":
-					bar.Handle.Destroy <- id
-				}
-			}
-		}
-
-		for i := 0; i < len(reloadEvents); i++ {
-			if event.Name == reloadEvents[i] {
-				reload <- true
-			}
-		}
-	}}()
-
-	return errors, reload
-}
-
 func main() {
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals,
@@ -84,58 +18,52 @@ func main() {
 		syscall.SIGHUP,
 		syscall.SIGTERM)
 
-	state, err := bspc.LoadState()
-	if err != nil {
-		common.Error("Couldn't load bspwm state: %s\n", err)
-		return
-	}
-
-	events, err := bspc.Subscribe()
-	if err != nil {
-		common.Error("Couldn't subscribe to bspwm: %s\n", err)
+	if bar.InitErr != nil {
+		common.Error("Couldn't initialize X: %s\n", bar.InitErr)
 		return
 	}
-	defer events.Close()
-
-	everr, evreload := handleEvents(events)
+	defer bar.Cleanup()
 
-	if bar.InitErr != nil {
-		common.Error("Couldn't initialize X: %s\n", err)
+	if bspc.InitErr != nil {
+		common.Error("Couldn't subscribe to bspwm: %s\n", bspc.InitErr)
 		return
 	}
-	defer bar.Cleanup()
-	bar.Handle.NewState <- state
+	defer bspc.Close()
 
-	for _, m := range state.Monitors {
+	bar.Handle.NewState <- bspc.Handle.State
+	for _, m := range bspc.Handle.State.Monitors {
 		bar.Handle.Create <- m.ID
 	}
 
 	for {
 		select {
-		case err := <- everr:
-			common.Error("Couldn't read event: %s\n", err)
-			return
 		case s := <- signals:
 			common.Error("%s\n", s)
 			return
 		case err := <- bar.Handle.Err:
 			common.Error("%s\n", err)
 			return
-		case <- evreload:
-			state, err = reloadState(state)
-			if err != nil {
-				common.Error("Couldn't reload bspwm state: %s\n", err)
-			}
-
-			// Check if there's been an error before sending the
-			// new state (or else the program gets stuck)
-			select {
-			case err := <- bar.Handle.Err:
-				common.Error("%s\n", err)
-				return
-			default:
+		case err := <- bspc.Handle.EvErr:
+			common.Error("Couldn't read event: %s\n", err)
+			return
+		case event := <- bspc.Handle.Event:
+			if strings.HasPrefix(event.Name, "monitor_") {
+				id, err := common.Intify(event.Tokens[0])
+				if err == nil {
+					switch (event.Name) {
+					case "monitor_add":
+					case "monitor_geometry":
+						bar.Handle.Create <- id
+					case "monitor_remove":
+						bar.Handle.Destroy <- id
+					}
+				}
 			}
-			bar.Handle.NewState <- state
+		case err := <- bspc.Handle.StErr:
+			common.Error("Couldn't load bspwm state: %s\n", err)
+			return
+		case <- bspc.Handle.StateUpdate:
+			bar.Handle.NewState <- bspc.Handle.State
 		}
 	}
 }