Single select in main controls entire process

1 files changed, 73 insertions, 35 deletions

diff --git a/bspc/bspc.go b/bspc/bspc.go
index 66a3006..75bdac3 100644
--- a/bspc/bspc.go
+++ b/bspc/bspc.go
@@ -77,7 +77,26 @@ type Desktop struct {
 	Root    *Node
 }
 
-func LoadState() (*State, error) {
+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 getState() (*State, error) {
 	cmd := exec.Command("bspc", "wm", "-d")
 
 	out, err := cmd.StdoutPipe()
@@ -115,13 +134,15 @@ func LoadState() (*State, error) {
 	return &state, nil
 }
 
-type Subscriber struct {
-	Event   chan *Event
-	Err     chan error
-	cleanup chan bool
-	cmd     *exec.Cmd
-	pipe    io.ReadCloser
-	scanner *bufio.Scanner
+type subscriber struct {
+	State       *State
+	StateUpdate chan bool
+	StErr       chan error
+	Event       chan *Event
+	EvErr       chan error
+	cmd         *exec.Cmd
+	pipe        io.ReadCloser
+	scanner     *bufio.Scanner
 }
 
 type Event struct {
@@ -129,67 +150,84 @@ type Event struct {
 	Tokens	[]string
 }
 
-func Subscribe() (*Subscriber, error) {
+var InitErr error
+var Handle  subscriber
+
+func init() {
 	cmd := exec.Command("bspc", "subscribe", "all")
 
 	pipe, err := cmd.StdoutPipe()
 	if err != nil {
-		return nil, common.Perror("cmd.StdoutPipe", err)
+		InitErr = common.Perror("cmd.StdoutPipe", err)
+		return
 	}
 
 	if err = cmd.Start(); err != nil {
-		return nil, common.Perror("cmd.Start", err)
+		InitErr = common.Perror("cmd.Start", err)
+		return
 	}
 
-	var s Subscriber
-	s.Event   = make(chan *Event)
-	s.Err     = make(chan error)
-	s.cleanup = make(chan bool)
-	s.cmd     = cmd
-	s.pipe    = pipe
-	s.scanner = bufio.NewScanner(s.pipe)
+	istate, err := getState()
+	if err != nil {
+		InitErr = common.Perror("getState", err)
+		return
+	}
+
+	Handle.State       = istate
+	Handle.StateUpdate = make(chan bool)
+	Handle.StErr       = make(chan error)
+	Handle.Event       = make(chan *Event)
+	Handle.EvErr       = make(chan error)
+	Handle.cmd         = cmd
+	Handle.pipe        = pipe
+	Handle.scanner     = bufio.NewScanner(Handle.pipe)
 
 	go func() { for {
-		event, err := s.get()
+		event, err := get()
 
 		if event != nil {
-			s.Event <- event
+			for i := 0; i < len(reloadEvents); i++ {
+				if event.Name == reloadEvents[i] {
+					state, serr := getState()
+					if serr != nil {
+						Handle.StErr <- serr
+						return
+					}
+					Handle.State = state
+					Handle.StateUpdate <- true
+				}
+			}
+			Handle.Event <- event
 		}
 
 		if err != nil {
-			s.Err <- err
+			Handle.EvErr <- err
 			return
 		}
 	}}()
-
-	return &s, nil
 }
 
-func (s *Subscriber) Close() {
-	s.cmd.Process.Kill()
+func Close() {
+	Handle.cmd.Process.Kill()
 }
 
-func (s *Subscriber) getLine() (string, error) {
-	if s.scanner.Scan() {
-		return s.scanner.Text(), nil
+func getLine() (string, error) {
+	if Handle.scanner.Scan() {
+		return Handle.scanner.Text(), nil
 	}
 
-	if err := s.scanner.Err(); err != nil {
+	if err := Handle.scanner.Err(); err != nil {
 		return "", common.Perror("scanner.Err", err)
 	}
 
 	return "", nil
 }
 
-func (s *Subscriber) get() (*Event, error) {
+func get() (*Event, error) {
 	var line string
 	var err  error
 	for {
-		line, err = s.getLine()
-		// if line == "W" {
-		// 	// Send this pseudo event so we know to reload the state
-		// 	return &Event{"reload", make([]string, 0)}, nil
-		// }
+		line, err = getLine()
 		if len(line) > 0 && line[0] != 'W' { break }
 	}