Add support for rate

Also fixed a few other things:
- bugs in active mode detection with my display (144hz and 60hz)
- Turn off changed displays in a smarter way. Im using usb-c daisychain
and had trouble with the current approach. it disabled my screen as soon
as the screen went into hibernate because xrandr stopped detecting the
display.
- some autoformatting of comments and code according to efficient go
guidelines
- if xrand (ApplyRule) fails, try 3 times with a little more sleep each
time. This also solved issues with my daisychained displays.

Fixes fd0#29

Author: Jonas Falck

cmd_apply.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	"time"
 )
 
 type CmdApply struct{}
@@ -37,23 +38,39 @@ func ApplyRule(outputs Outputs, rule Rule) error {
 		return fmt.Errorf("no output configuration for rule %v", rule.Name)
 	}
 
-	after := append(globalOpts.cfg.ExecuteAfter, rule.ExecuteAfter...)
-	if len(after) > 0 {
-		for _, cmd := range after {
-			cmds = append(cmds, exec.Command("sh", "-c", cmd))
-		}
-	}
-
 	if err != nil {
 		return err
 	}
+
+	foundError := false
 	for _, cmd := range cmds {
-		err = RunCommand(cmd)
-		if err != nil {
+		for i := 0; i < 4; i++ {
+			err = RunCommand(cmd)
+			if err == nil {
+				break
+			}
 			fmt.Fprintf(os.Stderr, "executing command for rule %v failed: %v\n", rule.Name, err)
+
+			dur := time.Millisecond * 500 * time.Duration(i)
+			fmt.Fprintf(os.Stderr, "trying again in %s", dur)
+			time.Sleep(dur)
 		}
+		if err != nil {
+			fmt.Fprint(os.Stderr, "failed after 3 retries")
+			foundError = true
+		}
+	}
+	if foundError {
+		return nil // Dont run ExecuteAfter if xrandr commands failed
 	}
 
+	after := append(globalOpts.cfg.ExecuteAfter, rule.ExecuteAfter...)
+	for _, cmd := range after {
+		err = RunCommand(exec.Command("sh", "-c", cmd))
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "executing command for rule %v failed: %v\n", rule.Name, err)
+		}
+	}
 	return nil
 }
 

cmd_watch.go

@@ -100,7 +100,6 @@ func (cmd CmdWatch) Execute(args []string) (err error) {
 	var eventReceived bool
 
 	var lastRule Rule
-	var lastOutputs Outputs
 	for {
 		if !disablePoll {
 			var outputs Outputs
@@ -117,53 +116,6 @@ func (cmd CmdWatch) Execute(args []string) (err error) {
 				return fmt.Errorf("detecting outputs: %w", err)
 			}
 
-			// disable outputs which have a changed display
-			var off Outputs
-			for _, o := range outputs {
-				for _, last := range lastOutputs {
-					if o.Name != last.Name {
-						continue
-					}
-
-					if last.Active() && !o.Active() {
-						V("  output %v: monitor not active any more, disabling", o.Name)
-						off = append(off, o)
-						continue
-					}
-
-					if o.Active() && o.MonitorId != last.MonitorId {
-						V("  output %v: monitor has changed, disabling", o.Name)
-						off = append(off, o)
-						continue
-					}
-				}
-			}
-
-			if len(off) > 0 {
-				V("disable %d outputs", len(off))
-
-				cmd, err := DisableOutputs(off)
-				if err != nil {
-					return fmt.Errorf("disabling outputs: %w", err)
-				}
-
-				// forget the last rule set, something has changed for sure
-				lastRule = Rule{}
-
-				err = RunCommand(cmd)
-				if err != nil {
-					fmt.Fprintf(os.Stderr, "error disabling: %v", err)
-				}
-
-				// refresh outputs again
-				outputs, err = GetOutputs()
-				if err != nil {
-					return fmt.Errorf("detecting outputs after disabling: %w", err)
-				}
-
-				V("new outputs after disable: %v", outputs)
-			}
-
 			rule, err := MatchRules(globalOpts.cfg.Rules, outputs)
 			if err != nil {
 				return fmt.Errorf("matching rules: %w", err)
@@ -173,6 +125,15 @@ func (cmd CmdWatch) Execute(args []string) (err error) {
 				V("outputs: %v", outputs)
 				V("new rule found: %v", rule.Name)
 
+				// Disable old rules outputs if they are not in current active rules outputs.
+				diff := rule.OutputsDiff(lastRule)
+				if len(diff) > 0 {
+					err = RunCommand(DisableOutputs(diff))
+					if err != nil {
+						fmt.Fprintf(os.Stderr, "error disabling: %v", err)
+					}
+				}
+
 				err = ApplyRule(outputs, rule)
 				if err != nil {
 					return fmt.Errorf("applying rules: %w", err)
@@ -185,15 +146,7 @@ func (cmd CmdWatch) Execute(args []string) (err error) {
 					disablePoll = true
 					backoffCh = time.After(time.Duration(globalOpts.Pause) * time.Second)
 				}
-
-				// refresh outputs for next cycle
-				outputs, err = GetOutputs()
-				if err != nil {
-					return fmt.Errorf("refreshing outputs: %w", err)
-				}
 			}
-
-			lastOutputs = outputs
 		}
 
 		select {

config.go

@@ -20,7 +20,7 @@ type Config struct {
 	OnFailure    []string `yaml:"on_failure"`
 }
 
-// xdgConfigDir returns the config directory according to the xdg standard, see
+// xdgConfigDir returns the config directory according to the xdg standard, see.
 // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html.
 func xdgConfigDir() string {
 	if dir := os.Getenv("XDG_CONFIG_HOME"); dir != "" {
@@ -37,7 +37,8 @@ func openConfigFile(name string) (io.ReadCloser, error) {
 		os.Getenv("GROBI_CONFIG"),
 		filepath.Join(xdgConfigDir(), "grobi.conf"),
 		filepath.Join(os.Getenv("HOME"), ".grobi.conf"),
-		"/etc/xdg/grobi.conf"} {
+		"/etc/xdg/grobi.conf",
+	} {
 		if filename != "" {
 			if f, err := os.Open(filename); err == nil {
 				V("reading config from %v\n", filename)
@@ -81,7 +82,6 @@ func readConfig(name string) (Config, error) {
 
 // Valid returns an error if the config is invalid, ie a pattern is malformed.
 func (cfg Config) Valid() error {
-
 	for _, rule := range cfg.Rules {
 		for _, list := range [][]string{rule.OutputsPresent, rule.OutputsAbsent, rule.OutputsConnected, rule.OutputsDisconnected} {
 			for _, pat := range list {

main.go

@@ -56,8 +56,10 @@ func RunCommand(cmd *exec.Cmd) error {
 	return cmd.Run()
 }
 
-var globalOpts = GlobalOptions{}
-var parser = flags.NewParser(&globalOpts, flags.Default)
+var (
+	globalOpts = GlobalOptions{}
+	parser     = flags.NewParser(&globalOpts, flags.Default)
+)
 
 func V(s string, data ...interface{}) {
 	if globalOpts.Verbose && globalOpts.log == nil {

randr.go

@@ -192,9 +192,9 @@ func (m Modes) String() string {
 	return strings.Join(str, " ")
 }
 
-// Generates the monitor id from the edid
+// Generates the monitor id from the edid.
 func GenerateMonitorId(s string) (string, error) {
-	var errEdidCorrupted = errors.New("corrupt EDID: " + s)
+	errEdidCorrupted := errors.New("corrupt EDID: " + s)
 	if len(s) < 32 || s[:16] != "00ffffffffffff00" {
 		return "", errEdidCorrupted
 	}
@@ -318,30 +318,40 @@ func parseModeLine(line string) (mode Mode, err error) {
 	}
 	mode.Name = ws.Text()
 
-	if !ws.Scan() {
-		return Mode{}, fmt.Errorf("line too short, no refresh rate found: %s", line)
-	}
-	rate := ws.Text()
+	i := 0
+	for ws.Scan() {
+		i++
+		rate := ws.Text()
+		if len(rate) == 0 {
+			break
+		}
+		if rate[len(rate)-1] == '+' {
+			mode.Default = true
+		}
 
-	if rate[len(rate)-1] == '+' {
-		mode.Default = true
-	}
+		if len(rate) > 1 && rate[len(rate)-2] == '*' {
+			mode.Active = true
+		}
 
-	if rate[len(rate)-2] == '*' {
-		mode.Active = true
-	}
+		if rate[len(rate)-1] == '*' {
+			mode.Active = true
+		}
 
-	// handle single-word "+", which happens when a mode is default but not active
-	if ws.Scan() && ws.Text() == "+" {
-		mode.Default = true
+		// handle single-word "+", which happens when a mode is default but not active
+		if ws.Text() == "+" {
+			mode.Default = true
+		}
+	}
+	if i == 0 {
+		return Mode{}, fmt.Errorf("line too short, no refresh rate found: %s", line)
 	}
 
 	return mode, nil
 }
 
 var errNotEdidLine = errors.New("not an edid line")
 
-// parseEdidLine returns the partial EDID on that line
+// parseEdidLine returns the partial EDID on that line.
 func parseEdidLine(line string) (edid string, err error) {
 	if !strings.HasPrefix(line, "		") {
 		return "", errNotEdidLine
@@ -513,14 +523,18 @@ func BuildCommandOutputRow(rule Rule, current Outputs) ([]*exec.Cmd, error) {
 	enableOutputArgs := [][]string{}
 
 	active := make(map[string]struct{})
-	var lastOutput = ""
+	lastOutput := ""
 	for i, output := range outputs {
-		data := strings.SplitN(output, "@", 2)
+		data := strings.SplitN(output, "@", 3)
 		name := data[0]
 		mode := ""
+		rate := ""
 		if len(data) > 1 {
 			mode = data[1]
 		}
+		if len(data) > 2 {
+			rate = data[2]
+		}
 
 		active[name] = struct{}{}
 
@@ -532,6 +546,10 @@ func BuildCommandOutputRow(rule Rule, current Outputs) ([]*exec.Cmd, error) {
 			args = append(args, "--mode", mode)
 		}
 
+		if rate != "" {
+			args = append(args, "--rate", rate)
+		}
+
 		if i > 0 {
 			if row {
 				args = append(args, "--right-of", lastOutput)
@@ -622,9 +640,9 @@ func BuildCommandOutputRow(rule Rule, current Outputs) ([]*exec.Cmd, error) {
 }
 
 // DisableOutputs returns a call to `xrandr` to switch off the specified outputs.
-func DisableOutputs(off Outputs) (*exec.Cmd, error) {
+func DisableOutputs(off Outputs) *exec.Cmd {
 	if len(off) == 0 {
-		return nil, nil
+		return nil
 	}
 
 	command := "xrandr"
@@ -638,5 +656,5 @@ func DisableOutputs(off Outputs) (*exec.Cmd, error) {
 
 	V("disable outputs: %v\n", outputs)
 
-	return exec.Command(command, args...), nil
+	return exec.Command(command, args...)
 }