Add config.File.Diff to diff two config files

Progress on #3

application.go

@@ -6,8 +6,10 @@ import "flag"
 import "image"
 import "strings"
 import "net/url"
+import "path/filepath"
 import "git.tebibyte.media/tomo/tomo"
 import "git.tebibyte.media/tomo/objects"
+import "git.tebibyte.media/tomo/nasin/config"
 import "git.tebibyte.media/tomo/nasin/internal/registrar"
 
 // Application represents an application object.
@@ -16,7 +18,11 @@ type Application interface {
 	Describe () ApplicationDescription
 
 	// Init performs the initial setup of the application.
-	Init () error
+	Init () (error)
+
+	// Stop stops the application and does not return until all ongoing
+	// operations have been completely shut down.
+	Stop ()
 }
 
 // ApplicationURLOpener is an application that can open a URL.
@@ -32,9 +38,8 @@ type ApplicationURLOpener interface {
 	OpenURL (*url.URL) error
 
 	// OpenNone is called when the application is launched without any URLs
-	// to open. The application may create some sort of default starting
-	// window, or call tomo.Stop().
-	OpenNone ()
+	// to open.
+	OpenNone () error
 }
 
 // ApplicationFlagAdder is an application that supports reading command line
@@ -154,8 +159,12 @@ func RunApplication (application Application) {
 	// open URLs
 	args := flag.Args()
 	applicationOpenUrls(application, args...)
-	err = backend.Run()
-	if err != nil { log.Fatalln("nasin: could not run application:", err) }
+
+	if manager.count > 0 {
+		err = backend.Run()
+		if err != nil { log.Fatalln("nasin: could not run application:", err) }
+	}
+	application.Stop()
 }
 
 // NewApplicationWindow creates a window for an application. It will
@@ -173,44 +182,79 @@ func NewApplicationWindow (application Application, bounds image.Rectangle) (tom
 	return window, nil
 }
 
-func applicationOpenUrls (application Application, args ...string) {
-	if application, ok := application.(ApplicationURLOpener); ok {
-		if len(args) <= 0 {
-			application.OpenNone()
-		}
+// ApplicationConfig opens a new config for the specified application. It must
+// be closed when it is no longer needed.
+func ApplicationConfig (app ApplicationDescription) (config.ConfigCloser, error) {
+	user, err := ApplicationUserConfigDir(app)
+	if err != nil { return nil, err }
+	user = filepath.Join(user, "config.conf")
+	system, err := ApplicationSystemConfigDirs(app)
+	if err != nil { return nil, err }
+	for index, path := range system {
+		system[index] = filepath.Join(path, "config.conf")
+	}
+	return config.NewConfig(user, system...)
+}
 
-		openedAny := false
-		for _, arg := range flag.Args() {
-			ur, err := url.Parse(arg)
-			if err != nil {
-				log.Fatalf (
-					"nasin: invalid URL %v: %v",
-					arg, err)
-			}
-			if ur.Scheme == "" {
-				ur.Scheme = "file"
-			}
-			err = application.OpenURL(ur)
-			if err != nil {
-				dialog, err := objects.NewDialogOk (
-					objects.DialogError, nil,
-					"Could Not Open URL",
-					fmt.Sprintf (
-						"Could not open %v: %v",
-						arg, err),
-					func () {
-						if !openedAny {
-							application.OpenNone()
-						}
-					})
-				if err != nil { log.Fatal(err) }
-				dialog.SetVisible(true)
-			}
-		}
-	} else {
+func errorPopupf (title, format string, v ...any) func (func ()) {
+	return func (callback func ()) {
+		dialog, err := objects.NewDialogOk (
+			objects.DialogError, nil,
+			title,
+			fmt.Sprintf(format, v...),
+			callback)
+		if err != nil { log.Fatal(err) }
+		dialog.SetVisible(true)
+		WaitFor(dialog)
+	}
+}
+
+func applicationOpenUrls (app Application, args ...string) {
+	application, ok := app.(ApplicationURLOpener)
+	if !ok {
 		if len(args) > 0 {
 			log.Fatal("nasin: this application cannot open URLs")
 		}
+		return
+	}
+	
+	openNone := func () bool {
+		err := application.OpenNone()
+		if err != nil {
+			log.Fatalf("nasin: could not open main window: %v", err)
+			return false
+		}
+		return true
+	}
+	
+	if len(args) <= 0 {
+		openNone()
+		return
+	}
+
+	openedAny := false
+	for _, arg := range flag.Args() {
+		ur, err := url.Parse(arg)
+		if err != nil {
+			log.Fatalf (
+				"nasin: invalid URL %v: %v",
+				arg, err)
+		}
+		if ur.Scheme == "" {
+			ur.Scheme = "file"
+		}
+		err = application.OpenURL(ur)
+		if err != nil {
+			errorPopupf(
+				"Could Not Open URL",
+				"Could not open %v: %v",
+				arg, err,
+			)(func () {
+				if !openedAny {
+					openNone()
+				}
+			})
+		}
 	}
 }
 

config/config.go

@@ -0,0 +1,155 @@
+// Package config provides a configuration system for applications.
+package config
+
+import "fmt"
+import "math"
+import "strconv"
+import "git.tebibyte.media/tomo/tomo/event"
+
+type configError string;
+func (err configError) Error () string { return string(err) }
+
+const (
+	// ErrClosed is returned when Get/Set/Reset is called after the config
+	// has been closed.
+	ErrClosed = configError("attempt to access a closed config")
+	// ErrNonexistentEntry is returned when an entry was not found.
+	ErrNonexistentEntry = configError("nonexistent entry")
+	// ErrMalformedEntry is returned when a config entry could not be
+	// parsed.
+	ErrMalformedEntry = configError("malformed entry")
+	// ErrMalformedKey is returned when a key has invalid runes.
+	ErrMalformedKey = configError("malformed key")
+	// ErrMalformedValue is returned when a value could not be parsed.
+	ErrMalformedValue = configError("malformed value")
+	// ErrMalformedString is returned when a string value could not be
+	// parsed.
+	ErrMalformedStringValue = configError("malformed string value")
+	// ErrMalformedNumber is returned when a number value could not be
+	// parsed.
+	ErrMalformedNumberValue = configError("malformed number value")
+	// ErrMalformedBool is returned when a boolean value could not be
+	// parsed.
+	ErrMalformedBoolValue = configError("malformed bool value")
+	// ErrMalformedEscapeSequence us returned when an escape sequence could
+	// not be parsed.
+	ErrMalformedEscapeSequence = configError("malformed escape sequence")
+)
+
+// Config provides access to an application's configuration, and can notify an
+// application of changes to it.
+type Config interface {
+	// Get gets a value, first considering the user-level config file, and
+	// then falling back to system level config files. If the value could
+	// not be found anywhere, the specified fallback value is returned. If
+	// the key is invalid, it returns nil, ErrMalformedKey.
+	Get (key string, fallback Value) (Value, error)
+	// GetString is like Get, but will only return strings. If the value is
+	// not a string, it will return fallback.
+	GetString (key string, fallback string) (string, error)
+	// GetNumber is like Get, but will only return numbers. If the value is
+	// not a number, it will return fallback.
+	GetNumber (key string, fallback float64) (float64, error)
+	// GetBool is like Get, but will only return booleans. If the value is
+	// not a boolean, it will return fallback.
+	GetBool (key string, fallback bool) (bool, error)
+	// Set sets a value in the user-level config file. If the key is
+	// invalid, it returns ErrMalformedKey.
+	Set (key string, value Value) error
+	// Reset removes the value from the user-level config file, resetting it
+	// to what is described by the system-level config files. If the key is
+	// invalid, it returns ErrMalformedKey.
+	Reset (key string) error
+	// OnChange specifies a function to be called whenever a value is
+	// changed. The callback is always run within the backend's event loop
+	// using tomo.Do. This could have been a channel but I didn't want to do
+	// that to people.
+	OnChange (func (key string)) event.Cookie
+}
+
+// ConfigCloser is a config with a Close behavior, which stops watching the
+// config file and causes any subsequent sets/gets to return errors. Anything
+// that receives a ConfigCloser must close it when done.
+type ConfigCloser interface {
+	Config
+	// Close closes the config, causing it to stop watching for changes.
+	// Reads or writes to the config after this will return an error.
+	Close () error
+}
+
+var negativeZero = math.Copysign(0, -1)
+
+// Value is a config value. Its String behavior produces a lossless and
+// syntactically valid representation of the value.
+type Value interface {
+	value ()
+	fmt.Stringer
+	Equals (Value) bool
+}
+
+// ValueString is a string value.
+type ValueString string
+var _ Value = ValueString("")
+func (ValueString) value () { }
+func (value ValueString) Equals (other Value) bool {
+	other, ok := other.(ValueString)
+	return ok && value == other
+}
+func (value ValueString) String () string {
+	return fmt.Sprintf("\"%s\"", escape(string(value)))
+}
+
+// ValueNumber is a number value.
+type ValueNumber float64
+var _ Value = ValueNumber(0)
+func (ValueNumber) value () { }
+func (value ValueNumber) Equals (other Value) bool {
+	other, ok := other.(ValueNumber)
+	return ok && value == other
+}
+func (value ValueNumber) String () string {
+	number := float64(value)
+	// the requirements I wrote said lossless in all cases. here's lossless
+	// in all cases!
+	switch {
+	case math.IsInf(number, 0):
+		if math.Signbit(number) {
+			return "-Inf"
+		} else {
+			return "Inf"
+		}
+		
+	case math.IsNaN(number):
+		return "NaN"
+		
+	case number == 0, number == negativeZero:
+		if math.Signbit(number) {
+			return "-0"
+		} else {
+			return "0"
+		}
+		
+	case math.Round(number) == number:
+		return strconv.FormatInt(int64(number), 10)
+		
+	default:
+		return strconv.FormatFloat(number, 'f', -1, 64)
+	}
+}
+
+
+// ValueBool is a boolean value.
+var _ Value = ValueBool(false)
+type ValueBool bool
+func (ValueBool) value () { }
+func (value ValueBool) Equals (other Value) bool {
+	other, ok := other.(ValueBool)
+	return ok && value == other
+}
+func (value ValueBool) String () string {
+	if value {
+		return "true"
+	} else {
+		return "false"
+	}
+}

config/escape.go

@@ -0,0 +1,97 @@
+package config
+
+import "fmt"
+import "strings"
+// import "unicode"
+
+var escapeCodeToRune = map[rune] rune {
+	'\\': '\\',
+	'a':  '\a',
+	'b':  '\b',
+	't':  '\t',
+	'n':  '\n',
+	'v':  '\v',
+	'f':  '\f',
+	'r':  '\r',
+	'"':  '"',
+}
+
+var runeToEscapeCode = map[rune] rune { }
+func init () {
+	for code, char := range escapeCodeToRune {
+		runeToEscapeCode[char] = code
+	}
+}
+
+func escape (str string) string {
+	builder := strings.Builder { }
+	for _, char := range str {
+		code, escaped := runeToEscapeCode[char]
+		switch {
+		case escaped:
+			fmt.Fprintf(&builder, "\\%c", code)
+		// case !unicode.IsPrint(char):
+			// fmt.Fprintf(&builder, "\\%o", char)
+		default:
+			builder.WriteRune(char)
+		}
+	}
+	return builder.String()
+}
+
+func unescape (str string) (string, bool) {
+	runes := []rune(str)
+	builder := strings.Builder { }
+
+	end := func () bool {
+		return len(runes) < 1
+	}
+	next := func () {
+		if !end() { runes = runes[1:] }
+	}
+	
+	for !end() {
+		if runes[0] == '\\' {
+			if end() { return "", false }
+			next()
+			char, isEscape := escapeCodeToRune[runes[0]]
+			switch {
+			case isEscape:
+				builder.WriteRune(char)
+				next()
+			// case isOctalDigit(runes[0]):
+				// char = 0
+				// for !end() && isOctalDigit(runes[0]) {
+					// char *= 8
+					// char += runes[0] - '0'
+					// next()
+				// }
+				// builder.WriteRune(char)
+			default:
+				return "", false
+			}
+		} else {
+			builder.WriteRune(runes[0])
+			next()
+		}
+	}
+	return builder.String(), true
+}
+
+func unquote (str string) (string, bool) {
+	if len(str) < 2             { return "", false }
+	if firstRune(str)    != '"' { return "", false }
+	if str[len(str) - 1] != '"' { return "", false }
+	return str[1:len(str) - 1], true
+}
+
+func isOctalDigit (char rune) bool {
+	return char >= '0' && char <= '7'
+}
+
+func firstRune (str string) rune {
+	for _, char := range str {
+		return char
+	}
+	return 0
+}

config/escape_test.go

@@ -0,0 +1,22 @@
+package config
+
+import "testing"
+
+func TestEscape (test *testing.T) {
+	expected := `\\\a\bhello\t\n\vworld!\f\r\"`
+	got      := escape("\\\a\bhello\t\n\vworld!\f\r\"")
+	if got != expected {
+		test.Fatalf("expected: [%s]\ngot:[%s]", expected, got)
+	}
+}
+
+func TestUnescape (test *testing.T) {
+	expected := "\\\a\bhello\t\n\vworld!\f\r\""
+	got, ok  := unescape(`\\\a\bhello\t\n\vworld!\f\r\"`)
+	if !ok {
+		test.Fatalf("text could not be unescaped")
+	}
+	if got != expected {
+		test.Fatalf("expected: [%s]\ngot:[%s]", expected, got)
+	}
+}

config/file.go

@@ -0,0 +1,266 @@
+package config
+
+import "io"
+import "fmt"
+import "math"
+import "bufio"
+import "errors"
+import "strconv"
+import "strings"
+import "unicode"
+
+type line any
+type comment string
+type entry struct { key string; value Value }
+
+// File represents a config file. It preserves the order of the lines, as well
+// as blank lines and comments.
+type File struct {
+	lines []line
+	keys  map[string] int
+}
+
+// NewFile creates a blank file with nothing in it.
+func NewFile () *File {
+	return &File {
+		 keys: make(map[string] int),
+	}
+}
+
+// Parse parses a config file from a reader. This function operates on a
+// best-effort basis: A file will always be returned, and any errors encountered
+// will be joined together.
+//
+// The general format of the file is as follows:
+//   - Encoded in UTF-8
+//   - Consists of lines, separated by \n, or \r\n
+//   - Lines can be any of these:
+//     - Blank line: has only whitespace
+//     - Comment: begins with a '#'
+//     - Entry: a key/value pair separated by an '=' sign
+//
+// For entries, all whitespace on either side of the '=' sign, the key, or the
+// value is ignored. The key may contain any letter or digit, as well as '-'
+// and '.'. The value is always identified by its first rune (after the
+// preliminary whitespace of course) and can be one of:
+//   - String: either a double-quoted string, or any string of runes not
+//     identifiable as any other kind of value. The quoted string is always
+//     unquoted when it is read. Either way, these escape sequences are
+//     supported, and resolved when they are read:
+//     - '\\': a literal backslash
+//     - '\a': alert, bell
+//     - '\b': backspace
+//     - '\t': horizontal tab
+//     - '\n': line feed
+//     - '\v': vertical tab
+//     - '\f': form feed
+//     - '\r': carriage return
+//     - '\"': double quote
+//   - Number: a floating point value. It can be of the form:
+//     - Inf
+//     - -Inf
+//     - NaN
+//     - [0-9]+
+//     - [0-9]+\.[0-9]*
+//   - Bool: a boolean value. It can be one of:
+//     - true
+//     - false
+//
+// Be aware that some unquoted strings, within reason, are subject to being read
+// as some other value in the future. For example, if there were suddenly a
+// third boolean value called glorble, the unquoted string glorble would be read
+// as a boolean value instead of a string.
+func Parse (reader io.Reader) (*File, error) {
+	file := &File {
+		keys: make(map[string] int),
+	}
+	errs    := []error { }
+	scanner := bufio.NewScanner(reader)
+	
+	for scanner.Scan() {
+		text := strings.TrimSpace(scanner.Text())
+		switch {
+		case text == "",  strings.HasPrefix(text, "#"):
+			file.lines = append(file.lines, comment(text))
+		default:
+			entry, err := parseEntry(text)
+			if err == nil {
+				file.keys[entry.key] = len(file.lines)
+				file.lines = append(file.lines, entry)
+			} else {
+				errs = append (errs, err )
+			}
+		}
+	}
+	errs = append(errs, scanner.Err())
+	return file, errors.Join(errs...)
+}
+
+func parseEntry (str string) (entry, error) {
+	key, value, ok := strings.Cut(str, "=")
+	if !ok { return entry { }, ErrMalformedEntry }
+	
+	key   = strings.TrimSpace(key)
+	if !KeyValid(key) { return entry { }, ErrMalformedKey }
+
+	value = strings.TrimSpace(value)
+	parsedValue, err := ParseValue(value)
+	if err != nil { return entry { }, err }
+	
+	return entry { key: key, value: parsedValue }, nil
+}
+
+// ParseValue parses a value from a string. For any Value v,
+// ParseValue(v.String()) should hold data exactly equal to v. This function
+// does not trim whitespace.
+func ParseValue (str string) (Value, error) {
+	first := firstRune(str)
+	switch {
+	case str == "":
+		return ValueString(""), nil
+	case first == '"':
+		value, ok := unescape(str)
+		if !ok { return nil, ErrMalformedEscapeSequence }
+		value, ok = unquote(value)
+		if !ok { return nil, ErrMalformedStringValue }
+		return ValueString(value), nil
+	case first == '-' || (first >= '0' && first <= '9'):
+		value, err := strconv.ParseFloat(str, 64)
+		if err != nil { return nil, ErrMalformedNumberValue }
+		return ValueNumber(value), nil
+	case str == "false":
+		return ValueBool(false), nil
+	case str == "true":
+		return ValueBool(true), nil
+	case str == "Inf":
+		return ValueNumber(math.Inf(1)), nil
+	case str == "NaN":
+		return ValueNumber(math.NaN()), nil
+	default:
+		value, ok := unescape(str)
+		if !ok { return nil, ErrMalformedEscapeSequence }
+		return ValueString(value), nil
+	}
+}
+
+// Has returns whether the key exists. If the key is invalid, it returns false,
+// ErrMalformedKey.
+func (this *File) Has (key string) (bool, error) {
+	if !KeyValid(key) { return false, ErrMalformedKey }
+	_, ok := this.keys[key]
+	return ok, nil
+}
+
+// Get gets the keyed value. If the value is unspecified, it returns nil,
+// ErrNonexistentEntry. If the key is invalid, it returns nil, ErrMalformedKey.
+func (this *File) Get (key string) (Value, error) {
+	if !KeyValid(key) { return nil, ErrMalformedKey }
+	if index, ok := this.keys[key]; ok {
+		if lin := this.lines[index].(entry); ok {
+			return lin.value, nil
+		}
+	}
+	return nil, ErrNonexistentEntry
+}
+
+// Set sets a value. If the key is invalid, it returns ErrMalformedKey.
+func (this *File) Set (key string, value Value) error {
+	if !KeyValid(key) { return ErrMalformedKey }
+	if index, ok := this.keys[key]; ok {
+		ent := this.lines[index].(entry)
+		ent.value = value
+		this.lines[index] = ent
+		return nil
+	}
+	this.keys[key] = len(this.lines)
+	this.lines     = append(this.lines, value)
+	return nil
+}
+
+// Reset removes the value from the file. If the value is set again, it will be
+// added back at the same location. Note that because of this, the positions of
+// lines are not forgotten until the file is written and reloaded. This is why
+// the method is called Reset and not Remove. If the key is invalid, it returns
+// ErrMalformedKey.
+func (this *File) Reset (key string) error {
+	if !KeyValid(key) { return ErrMalformedKey }
+	for index, lin := range this.lines {
+		if lin, ok := lin.(entry); ok {
+			if lin.key == key {
+				this.lines[index] = nil
+			}
+		}
+	}
+	return nil
+}
+
+// Map creates and returns a map of keys to values.
+func (this *File) Map () map[string] Value {
+	mp := make(map[string] Value)
+	for key, index := range this.keys {
+		if lin, ok := this.lines[index].(entry); ok {
+			mp[key] = lin.value
+		}
+	}
+	return mp
+}
+
+// Diff returns a set of keys that are different from the other file.
+func (this *File) Diff (other *File) map[string] struct { } {
+	diff := make(map[string] struct { })
+	
+	// - keys only we have
+	// - keys we both have, but are different
+	for key, index := range this.keys {
+		otherIndex, ok := other.keys[key]
+		if !ok {
+			diff[key] = struct { } { }
+			continue
+		}
+		if !this.lines[index].(entry).value.Equals(other.lines[otherIndex].(entry).value) {
+			diff[key] = struct { } { }
+		}
+	}
+
+	// - keys only they have
+	for key := range other.keys {
+		if _, has := this.keys[key]; !has {
+			diff[key] = struct { } { }
+		}
+	}
+
+	return diff
+}
+
+// WriteTo writes the data in this file to an io.Writer.
+func (file *File) WriteTo (writer io.Writer) (n int64, err error) {
+	for _, lin := range file.lines {
+		nint := 0
+		switch lin := lin.(type) {
+		case comment:
+			nint, err = fmt.Fprintln(writer, string(lin))
+		case entry:
+			nint, err = fmt.Fprintf(writer, "%s=%v\n", lin.key, lin.value)
+		}
+		n += int64(nint)
+		if err != nil { return n, err }
+	}
+	return n, nil
+}
+
+// KeyValid returns whether a key contains only valid runes. They are:
+//   - Letters
+//   - Digits
+//   - '-'
+//   - '.'
+func KeyValid (key string) bool {
+	for _, char := range key {
+		valid :=
+			char == '.' ||
+			char == '-' ||
+			unicode.IsLetter(char) ||
+			unicode.IsDigit(char)
+		if !valid { return false }
+	}
+	return true
+}

config/file_test.go

@@ -0,0 +1,192 @@
+package config
+
+import "math"
+import "maps"
+import "strings"
+import "testing"
+
+func TestParseEntryUnquotedString (test *testing.T) {
+	testParseEntry(test, "stringValue = Unquoted\\nString", "stringValue", ValueString("Unquoted\nString"))
+}
+
+func TestParseEntryQuotedString (test *testing.T) {
+	testParseEntry(test, "stringValue = \"Quoted\\nString\"", "stringValue", ValueString("Quoted\nString"))
+}
+
+func TestParseEntryNumber (test *testing.T) {
+	testParseEntry(test, "numberValue = -349.29034", "numberValue", ValueNumber(-349.29034))
+}
+
+func TestParseEntryNumberInf (test *testing.T) {
+	testParseEntry(test, "numberValue = Inf", "numberValue", ValueNumber(math.Inf(1)))
+}
+
+func TestParseEntryNumberNegativeInf (test *testing.T) {
+	testParseEntry(test, "numberValue = -Inf", "numberValue", ValueNumber(math.Inf(-1)))
+}
+
+func TestParseEntryNumberNaN (test *testing.T) {
+	testParseEntry(test, "numberValue = NaN", "numberValue", ValueNumber(math.NaN()))
+}
+
+func TestParseEntryBoolTrue (test *testing.T) {
+	testParseEntry(test, "boolValue = true", "boolValue", ValueBool(true))
+}
+
+func TestParseEntryBoolFalse (test *testing.T) {
+	testParseEntry(test, "boolValue = false", "boolValue", ValueBool(false))
+}
+
+func TestParseEntryComplexKey (test *testing.T) {
+	testParseEntry (
+		test, "--Something.OtherThing...another-Thing-=value",
+		"--Something.OtherThing...another-Thing-", ValueString("value"))
+}
+
+func TestParse (test *testing.T) {
+testParse(test,
+`  thing  =something
+# comment
+
+   otherThing   = otherValue
+   otherThing = otherValue1
+   otherThing = otherValue2 # not a comment
+`,
+`thing="something"
+# comment
+
+otherThing="otherValue"
+otherThing="otherValue1"
+otherThing="otherValue2 # not a comment"
+`)
+}
+
+func TestGetValue (test *testing.T) {
+	file := parseFileString(test,
+`key=askdhj
+# some comment
+key = value
+key1 = 7`)
+	got, err := file.Get("key")
+	if err != nil { test.Fatal(err) }
+	testValueString(test, got, `"value"`)
+}
+
+func TestModifyValue (test *testing.T) {
+	file := parseFileString(test,
+`key=askdhj
+# some comment
+key = value
+key1 = 7`)
+	err := file.Set("key", ValueNumber(324980.2349))
+	if err != nil { test.Fatal(err) }
+	testFileString(test, file,
+`key="askdhj"
+# some comment
+key=324980.2349
+key1=7
+`)
+}
+
+func TestResetValue (test *testing.T) {
+	file := parseFileString(test,
+`key=askdhj
+# some comment
+key = value
+
+key1 = 7`)
+	err := file.Reset("key")
+	if err != nil { test.Fatal(err) }
+	testFileString(test, file,
+`# some comment
+
+key1=7
+`)
+}
+
+func TestDiffNone (test *testing.T) {
+	str := `
+thing = something
+
+otherThing  = otherValue
+# comment
+otherThing = true
+otherThing = 234
+
+yetAnotherThing = 0.23498
+`
+	file1 := parseFileString(test, str)
+	file2 := parseFileString(test, str)
+	diff := file1.Diff(file2)
+	if len(diff) != 0 {
+		test.Fatalf("diff not empty:\n%v", diff)
+	}
+}
+
+func TestDiff (test *testing.T) {
+	file1 := parseFileString(test,
+`key4=0
+key1=value1
+# comment
+key2=34`)
+	file2 := parseFileString(test,
+`key1=value2
+key2=34
+# comment
+
+key3=0.2`)
+	diff := file1.Diff(file2)
+	correct := map[string] struct { } {
+		"key1": struct { } { },
+		"key3": struct { } { },
+		"key4": struct { } { },
+	}
+	if !maps.Equal(diff, correct) {
+		test.Error("diffs do not match")
+		test.Errorf("EXPECTED:\n%v", correct)
+		test.Errorf("GOT:\n%v", diff)
+		test.Fail()
+	}
+}
+
+func testParseEntry (test *testing.T, str string, key string, value Value) {
+	ent, err := parseEntry(str)
+	if err != nil { test.Fatal(err) }
+	if ent.key != key {
+		test.Fatalf("expected key: [%s]\ngot key: [%s]", key, ent.key)
+	}
+	if ent.value.String() != value.String() {
+		test.Fatalf("expected value: [%s]\ngot value: [%s]", value.String(), ent.value.String())
+	}
+}
+
+func testParse (test *testing.T, str, correct string) {
+	if correct == "" { correct = str }
+	testFileString(test, parseFileString(test, str), correct)
+}
+
+func parseFileString (test *testing.T, str string) *File {
+	file, err := Parse(strings.NewReader(str))
+	if err != nil { test.Fatal(err) }
+	return file
+}
+
+func testFileString (test *testing.T, file *File, correct string) {
+	got := strings.Builder { }
+	file.WriteTo(&got)
+	if got.String() != correct {
+		test.Error("strings do not match")
+		test.Errorf("EXPECTED:\n%s", correct)
+		test.Errorf("GOT:\n%s", got.String())
+		test.Fail()
+	}
+}
+
+func testValueString (test *testing.T, got Value, correct string) {
+	if got.String() != correct {
+		test.Error("strings do not match")
+		test.Errorf("EXPECTED:\n%s", correct)
+		test.Errorf("GOT:\n%s", got.String())
+		test.Fail()
+	}
+}

config/impl.go

@@ -0,0 +1,248 @@
+package config
+
+import "os"
+import "log"
+import "sync"
+import "slices"
+import "path/filepath"
+import "github.com/fsnotify/fsnotify"
+import "git.tebibyte.media/tomo/tomo/event"
+
+// Goroutine model:
+// All private methods (except for lockAndProcessEvent) do not lock the config,
+// but all public methods do. Private methods may not call public methods.
+// Locking must always be method-level, with a call to Lock at the start,
+// directly followed by a deferred call to Unlock.
+
+type config struct {
+	open    bool
+	watcher *fsnotify.Watcher
+	lock    sync.RWMutex
+
+	paths struct {
+		user     string
+		system   []string
+		watching map[string] struct { }
+	}
+
+	data struct {
+		user   *File
+		system []map[string] Value
+	}
+	
+	on struct {
+		change event.Broadcaster[func (string)]
+	}
+}
+
+// NewConfig creates a new Config using paths to the user-level config file, and
+// a set of system config files. These files need not exist: the user-level file
+// will be created when Set is called for the first time if it does not exist
+// already, and nonexistent system files are simply ignored (unless the Config
+// finds them at any point to have been spontaneously created).
+//
+// The user file is written to when Set is called, and the system files are only
+// read from. Values in the user file override those in the system files, and
+// system files specified nearer to the start of the vararg list will override
+// those farther down.
+func NewConfig (user string, system ...string) (ConfigCloser, error) {
+	conf := new(config)
+	conf.paths.user   = user
+	conf.paths.system = system
+	err := conf.init()
+	if err != nil { return nil, err }
+	go func () {
+		for event := range conf.watcher.Events {
+			conf.lockAndProcessEvent(event)
+		}
+	} ()
+	return conf, nil
+}
+
+// this method may only be run in the goroutine spawned by NewConfig.
+func (this *config) lockAndProcessEvent (event fsnotify.Event) {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	if !(event.Has(fsnotify.Write))                  { return }
+	if _, ok := this.paths.watching[event.Name]; !ok { return }
+
+	if event.Name == this.paths.user {
+		this.reloadUser()
+	} else {
+		index := slices.Index(this.paths.system, event.Name)
+		if index > 0 {
+			this.reloadSystem(index)
+		}
+	}
+
+	// TODO diff and call event handler if changed
+}
+
+func (this *config) init () error {
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil { return err }
+	this.watcher = watcher
+	
+	this.paths.watching = make(map[string] struct { })
+	this.watcher.Add(filepath.Dir(this.paths.user))
+	this.paths.watching[this.paths.user] = struct { } { }
+	this.reloadUser()
+	for index, path := range this.paths.system {
+		this.watcher.Add(filepath.Dir(path))
+		this.paths.watching[path] = struct { } { }
+		this.reloadSystem(index)
+	}
+
+	return nil
+}
+
+func (this *config) errIfClosed () error {
+	if this.open {
+		return nil
+	} else {
+		return ErrClosed
+	}
+}
+
+func (this *config) reloadUser () {
+	file, err := os.Open(this.paths.user)
+	if err != nil { return }
+	defer file.Close()
+	
+	userFile, err := Parse(file)
+	if err != nil {
+		log.Printf("nasin: problems loading user config file %s: %v", this.paths.user, err)
+		return
+	}
+	this.data.user = userFile
+}
+
+func (this *config) reloadSystem (index int) {
+	path := this.paths.system[index]
+	file, err := os.Open(path)
+	if err != nil { return }
+	defer file.Close()
+	
+	systemFile, err := Parse(file)
+	if err != nil {
+		log.Printf("nasin: problems loading system config file %s: %v", path, err)
+		return
+	}
+	this.data.system[index] = systemFile.Map()
+}
+
+func (this *config) saveUser () error {
+	// TODO set some sort of flag to ignore the next inotify event for the
+	// user file so we dont reload it immediately after. also need to
+	// broadacast Changed event.
+	enclosingDir := filepath.Dir(this.paths.user)
+	err := os.MkdirAll(enclosingDir, 755)
+	if err != nil { return err }
+	file, err := os.Create(this.paths.user)
+	if err != nil { return err }
+	defer file.Close()
+	_, err = this.data.user.WriteTo(file)
+	if err != nil { return err }
+	return nil
+}
+
+func (this *config) processUserDiff (changed []string) {
+	// TODO
+}
+
+func (this *config) processSystemDiff (index int, changed []string) {
+	// TODO
+}
+
+func (this *config) get (key string, fallback Value) (Value, error) {
+	// try user config
+	if !KeyValid(key) { return nil, ErrMalformedKey }
+
+	if this.data.user != nil {
+		value, err := this.data.user.Get(key)
+		if err == nil && err != ErrNonexistentEntry {
+			return value, nil
+		}
+	}
+
+	// try system configs
+	for _, config := range this.data.system {
+		if value, ok := config[key]; ok {
+			return value, nil
+		}
+	}
+
+	// use fallback
+	return fallback, nil
+	
+}
+
+func (this *config) Get (key string, fallback Value) (Value, error) {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	return this.get(key, fallback)
+}
+
+func (this *config) Close () error {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	this.open = false
+	return this.watcher.Close()
+}
+
+func (this *config) GetString (key string, fallback string) (string, error) {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	value, err := this.get(key, ValueString(fallback))
+	if err != nil { return "", err }
+	if value, ok := value.(ValueString); ok {
+		return string(value), nil
+	}
+	return fallback, nil
+}
+
+func (this *config) GetNumber (key string, fallback float64) (float64, error) {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	value, err := this.get(key, ValueNumber(fallback))
+	if err != nil { return 0, err }
+	if value, ok := value.(ValueNumber); ok {
+		return float64(value), nil
+	}
+	return fallback, nil
+}
+
+func (this *config) GetBool (key string, fallback bool) (bool, error) {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	value, err := this.get(key, ValueBool(fallback))
+	if err != nil { return false, err }
+	if value, ok := value.(ValueBool); ok {
+		return bool(value), nil
+	}
+	return fallback, nil
+}
+
+func (this *config) Set (key string, value Value) error {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	if this.data.user == nil { this.data.user = NewFile() }
+	err := this.data.user.Set(key, value)
+	if err != nil { return err }
+	return this.saveUser()
+}
+
+func (this *config) Reset (key string) error {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	if this.data.user == nil { this.data.user = NewFile() }
+	err := this.data.user.Reset(key)
+	if err != nil { return err }
+	return this.saveUser()
+}
+
+func (this *config) OnChange (callback func (string)) event.Cookie {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	return this.on.change.Connect(callback)
+}

go.mod

@@ -4,10 +4,11 @@ go 1.22.2
 
 require (
 	git.tebibyte.media/sashakoshka/goparse v0.2.0
-	git.tebibyte.media/tomo/backend v0.6.1
-	git.tebibyte.media/tomo/objects v0.21.0
-	git.tebibyte.media/tomo/tomo v0.45.0
+	git.tebibyte.media/tomo/backend v0.7.0
+	git.tebibyte.media/tomo/objects v0.22.0
+	git.tebibyte.media/tomo/tomo v0.46.1
 	git.tebibyte.media/tomo/xdg v0.1.0
+	github.com/fsnotify/fsnotify v1.7.0
 	golang.org/x/image v0.11.0
 )
 
@@ -18,4 +19,5 @@ require (
 	github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966 // indirect
 	github.com/jezek/xgb v1.1.1 // indirect
 	github.com/jezek/xgbutil v0.0.0-20231116234834-47f30c120111 // indirect
+	golang.org/x/sys v0.5.0 // indirect
 )

go.sum

@@ -1,12 +1,12 @@
 git.tebibyte.media/sashakoshka/goparse v0.2.0 h1:uQmKvOCV2AOlCHEDjg9uclZCXQZzq2PxaXfZ1aIMiQI=
 git.tebibyte.media/sashakoshka/goparse v0.2.0/go.mod h1:tSQwfuD+EujRoKr6Y1oaRy74ZynatzkRLxjE3sbpCmk=
 git.tebibyte.media/sashakoshka/xgbkb v1.0.0/go.mod h1:pNcE6TRO93vHd6q42SdwLSTTj25L0Yzggz7yLe0JV6Q=
-git.tebibyte.media/tomo/backend v0.6.1 h1:TVbvfbcMrF8YAVGsXPQNQLCam3xuOWJmZA0B+op0ig0=
-git.tebibyte.media/tomo/backend v0.6.1/go.mod h1:7gl0Z1V8Vcns41pXIpQt1FYlANrQf5bCboxMjTCCrgc=
-git.tebibyte.media/tomo/objects v0.21.0 h1:exFbzQPQhGIVQK5BCDg69ZV96zMamV50G4GRsnK+yfA=
-git.tebibyte.media/tomo/objects v0.21.0/go.mod h1:ljnNcCuNfvcYLHmQrEU7LuG0OvQiAVDCXU+ajspq+TI=
-git.tebibyte.media/tomo/tomo v0.45.0 h1:fQH0WIPidW275hOq9dE6R7p064xG1RGx2QU68Avlr84=
-git.tebibyte.media/tomo/tomo v0.45.0/go.mod h1:WrtilgKB1y8O2Yu7X4mYcRiqOlPR8NuUnoA/ynkQWrs=
+git.tebibyte.media/tomo/backend v0.7.0 h1:12A+IsbwIKCmg4jKjD9xCDz+o7R3X6Yp8cZup+wOGIM=
+git.tebibyte.media/tomo/backend v0.7.0/go.mod h1:G3Kh6N2MuiAwsnuPe3h9CwWL65vmmsaqgapA38MPyhk=
+git.tebibyte.media/tomo/objects v0.22.0 h1:2t21W32HW2xvPBICqmArVMVWxg9ohhTJw6ChZ0DcdYY=
+git.tebibyte.media/tomo/objects v0.22.0/go.mod h1:f5J5tAhO+eN5glVbCJLPSopIeTylXqLgKLVAIg8iAPQ=
+git.tebibyte.media/tomo/tomo v0.46.1 h1:/8fT6I9l4TK529zokrThbNDHGRvUsNgif1Zs++0PBSQ=
+git.tebibyte.media/tomo/tomo v0.46.1/go.mod h1:WrtilgKB1y8O2Yu7X4mYcRiqOlPR8NuUnoA/ynkQWrs=
 git.tebibyte.media/tomo/typeset v0.7.1 h1:aZrsHwCG5ZB4f5CruRFsxLv5ezJUCFUFsQJJso2sXQ8=
 git.tebibyte.media/tomo/typeset v0.7.1/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
 git.tebibyte.media/tomo/xdg v0.1.0 h1:6G2WYPPiM2IXleCpKKHuJA34BxumwNWuLsUoX3yu5zA=
@@ -17,6 +17,8 @@ github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298 h1:1qlsVAQJ
 github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298/go.mod h1:D+QujdIlUNfa0igpNMk6UIvlb6C252URs4yupRUV4lQ=
 github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966 h1:lTG4HQym5oPKjL7nGs+csTgiDna685ZXjxijkne828g=
 github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966/go.mod h1:Mid70uvE93zn9wgF92A/r5ixgnvX8Lh68fxp9KQBaI0=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
 github.com/jezek/xgb v1.1.0/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
 github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
 github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
@@ -42,6 +44,7 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=

internal/icons/fallback/icon.go

@@ -6,6 +6,7 @@ import _ "embed"
 import _ "image/png"
 import "git.tebibyte.media/tomo/tomo"
 import "git.tebibyte.media/tomo/tomo/data"
+import "git.tebibyte.media/tomo/nasin/internal/util"
 import "git.tebibyte.media/tomo/tomo/canvas"
 import "git.tebibyte.media/tomo/backend/style"
 
@@ -14,6 +15,26 @@ var atlasSmallBytes []byte
 //go:embed assets/icons-large.png
 var atlasLargeBytes []byte
 
+const (
+	iconApplicationXGeneric    = tomo.Icon("application/x-generic")
+	iconApplicationXExecutable = tomo.Icon("application/x-executable")
+	iconAudioXGeneric          = tomo.Icon("audio/x-generic")
+	iconFontXGeneric           = tomo.Icon("font/x-generic")
+	iconImageXGeneric          = tomo.Icon("image/x-generic")
+	iconModelXGeneric          = tomo.Icon("model/x-generic")
+	iconPackageXGeneric        = tomo.Icon("package/x-generic")
+	iconTextXGeneric           = tomo.Icon("text/x-generic")
+	iconTextHtml               = tomo.Icon("text/html")
+	iconTextXGenericTemplate   = tomo.Icon("text/x-generic-template")
+	iconTextXScript            = tomo.Icon("text/x-script")
+	iconVideoXGeneric          = tomo.Icon("video/x-generic")
+	iconXOfficeAddressBook     = tomo.Icon("x-office-address-book")
+	iconXOfficeCalendar        = tomo.Icon("x-office-calendar")
+	iconXOfficeDocument        = tomo.Icon("x-office-document")
+	iconXOfficePresentation    = tomo.Icon("x-office-presentation")
+	iconXOfficeSpreadsheet     = tomo.Icon("x-office-spreadsheet")
+)
+
 func generateSource (data []byte, width int) map[tomo.Icon] canvas.Texture {
 	atlasImage, _, err := image.Decode(bytes.NewReader(data))
 	if err != nil { panic(err) }
@@ -37,7 +58,23 @@ func generateSource (data []byte, width int) map[tomo.Icon] canvas.Texture {
 	}
 
 	col(tomo.IconUnknown)
-	col(tomo.Icon("File"))
+	col(iconApplicationXGeneric)
+	col(iconApplicationXExecutable)
+	col(iconAudioXGeneric)
+	col(iconFontXGeneric)
+	col(iconImageXGeneric)
+	col(iconModelXGeneric)
+	col(iconPackageXGeneric)
+	col(iconTextXGeneric)
+	col(iconTextHtml)
+	col(iconTextXGenericTemplate)
+	col(iconTextXScript)
+	col(iconVideoXGeneric)
+	col(iconXOfficeAddressBook)
+	col(iconXOfficeCalendar)
+	col(iconXOfficeDocument)
+	col(iconXOfficePresentation)
+	col(iconXOfficeSpreadsheet)
 
 	row()
 	// actions
@@ -111,9 +148,14 @@ func generateSource (data []byte, width int) map[tomo.Icon] canvas.Texture {
 	col(tomo.IconInsertLink)
 	col(tomo.IconInsertObject)
 	col(tomo.IconInsertText)
+
+	row()
 	// actions: list
 	col(tomo.IconListAdd)
 	col(tomo.IconListRemove)
+	col(tomo.IconListChoose)
+	col(tomo.IconListExpand)
+	col(tomo.IconListContract)
 
 	row()
 	// actions: mail
@@ -311,9 +353,6 @@ func generateSource (data []byte, width int) map[tomo.Icon] canvas.Texture {
 	col(tomo.IconPlacePreferences)
 
 	row()
-	// status: checkbox
-	col(tomo.IconCheckboxChecked)
-	col(tomo.IconCheckboxUnchecked)
 	// status: appointments
 	col(tomo.IconAppointmentMissed)
 	col(tomo.IconAppointmentSoon)
@@ -448,9 +487,16 @@ func (this *iconSet) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
 func (this *iconSet) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
 	this.ensure()
 	source := this.selectSource(size)
+
+	if icon, ok := source[tomo.Icon(mime.String())]; ok {
+		return icon
+	}
+
 	if mime == data.M("inode", "directory") {
 		return source[tomo.IconPlaceDirectory]
+	} else if icon, ok := source[tomo.Icon(util.GeneralizeXDGIconMimeType(mime).String())]; ok {
+		return icon
 	} else {
-		return source[tomo.Icon("File")]
+		return source[tomo.Icon(iconApplicationXGeneric)]
 	}
 }

internal/icons/xdg/icon.go

@@ -11,6 +11,7 @@ import "git.tebibyte.media/tomo/tomo"
 import "git.tebibyte.media/tomo/tomo/data"
 import "git.tebibyte.media/tomo/tomo/canvas"
 import "git.tebibyte.media/tomo/backend/style"
+import "git.tebibyte.media/tomo/nasin/internal/util"
 import xdgIconTheme "git.tebibyte.media/tomo/xdg/icon-theme"
 
 type iconTheme struct {
@@ -113,7 +114,7 @@ func (this *iconTheme) mimeIcon (mime data.Mime, size tomo.IconSize) canvas.Text
 	if texture, ok := this.xdgIcon(xdgFormatMime(mime), size); ok {
 		return texture
 	}
-	if texture, ok := this.xdgIcon(xdgFormatMime(generalizeMimeType(mime)), size); ok {
+	if texture, ok := this.xdgIcon(xdgFormatMime(util.GeneralizeXDGIconMimeType(mime)), size); ok {
 		return texture
 	}
 	if texture, ok := this.xdgIcon(xdgFormatMime(data.M("text", "x-generic")), size); ok {
@@ -166,13 +167,6 @@ func xdgFormatMime (mime data.Mime) string {
 	return fmt.Sprintf("%s-%s", mime.Type, mime.Subtype)
 }
 
-func generalizeMimeType (mime data.Mime) data.Mime {
-	// FIXME make this more accurate
-	// https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
-	mime.Subtype = "x-generic"
-	return mime
-}
-
 func iconSizePixels (size tomo.IconSize) int {
 	// TODO: once Tomo has scaling support, take that into account here
 	switch size {

internal/styles/aluminum/aluminum.tss

@@ -19,18 +19,18 @@ $ColorCalendarWeekend       = #c2d3c4;
 $ColorCalendarDay           = #d6dae2;
 
 // Borders
-$BorderOutline        = $ColorOutline                   / 1;
-$BorderEngraved       = #c3c3c5 #e3e3e3 #e9e9e9 #c2c2c2 / 1;
-$BorderGap            = #697c7c #566767 #566767 #697c7c / 1;
-$BorderLifted         = #f9fafc #c2c8d3 #a4afc0 #f5f6f8 / 1;
-$BorderLiftedFocused  = #f0f4f9 #b1baca #9aa6b7 #e4e9ee / 1;
-$BorderFocused        = #5f8bc4 #5f8bc4 #5f8bc4 #5f8bc4 / 1;
-$BorderTear           = $BorderEngraved;
-$BorderTearFocused    = #7f94b5 #ced7e4 #ced7e4 #7f94b5 / 1;
-$BorderTearPad        = #0000                           / 3;
-$BorderTearPadFocused = #7391c080                       / 3;
-$BorderInnerShadow    = #a4afc0                         / 1 0 0 1;
-$BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
+$BorderOutline        = $ColorOutline                  ;
+$BorderEngraved       = #c3c3c5 #e3e3e3 #e9e9e9 #c2c2c2;
+$BorderGap            = #697c7c #566767 #566767 #697c7c;
+$BorderLifted         = #f9fafc #c2c8d3 #a4afc0 #f5f6f8;
+$BorderLiftedFocused  = #f0f4f9 #b1baca #9aa6b7 #e4e9ee;
+$BorderFocused        = #5f8bc4 #5f8bc4 #5f8bc4 #5f8bc4;
+$BorderTear           = $BorderEngraved                ;
+$BorderTearFocused    = #7f94b5 #ced7e4 #ced7e4 #7f94b5;
+$BorderTearPad        = #0000                          ;
+$BorderTearPadFocused = #7391c080                      ;
+$BorderInnerShadow    = #a4afc0                        ;
+$BorderOuterShadow    = #a4afc0                        ;
 
 *.* {
 	TextColor: $ColorForeground;
@@ -39,13 +39,13 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 }
 
 *.Button {
-	Border:  $BorderEngraved, $BorderGap, $BorderLifted;
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderLifted / 1;
 	Padding: 4 8;
 	Color:   $ColorRaised;
 }
 
 *.Button[focused] {
-	Border:  $BorderEngraved, $BorderGap, $BorderLiftedFocused;
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderLiftedFocused / 1;
 	Padding: 4 8;
 	Color:   $ColorRaisedFocused;
 }
@@ -55,23 +55,23 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 }
 
 *.Button[pressed] {
-	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
 	Padding: 5 8 4 9;
 	Color:   $ColorRaisedPressed;
 }
 
 *.TextInput {
-	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
 	Padding: 5 4 4 5;
 	Color:   $ColorSunken;
 }
 
 *.TextInput[focused] {
-	Border: $BorderEngraved, $BorderFocused, $BorderInnerShadow;
+	Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
 }
 
 *.TextView {
-	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
 	Padding: 5 4 4 5;
 	Color:   $ColorSunken;
 }
@@ -81,7 +81,7 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 }
 
 *.Container[sunken] {
-	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
 	Padding: 5 4 4 5;
 	Color:   $ColorSunken;
 }
@@ -92,7 +92,13 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 }
 
 *.Container[menu] {
-	Border: $BorderGap, $BorderLifted;
+	Border: $BorderGap / 1, $BorderLifted / 1;
+	Color:  $ColorBackground;
+	Gap:    0;
+}
+
+*.Container[menu, torn] {
+	Border: ;
 	Color:  $ColorBackground;
 	Gap:    0;
 }
@@ -101,17 +107,22 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 	Align: middle middle;
 }
 
+*.Heading[menu] {
+	Align:   middle middle;
+	Padding: 4 8;
+}
+
 *.Separator {
-	Border: $BorderEngraved;
+	Border: $BorderEngraved / 1;
 }
 
 *.Slider {
-	Border: $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
 	Color:  $ColorGutter;
 }
 
 *.Slider[focused] {
-	Border: $BorderEngraved, $BorderFocused, $BorderInnerShadow;
+	Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
 }
 
 *.Slider[hovered] {
@@ -127,7 +138,34 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 }
 
 *.SliderHandle {
-	Border:      $BorderOuterShadow, $BorderGap, $BorderLifted;
+	Border:      $BorderOuterShadow / 0 1 1 0, $BorderGap / 1, $BorderLifted / 1;
+	Color:       $ColorRaised;
+	MinimumSize: 12;
+}
+
+*.Scrollbar {
+	Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Color:  $ColorGutter;
+}
+
+*.Scrollbar[focused] {
+	Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
+}
+
+*.Scrollbar[hovered] {
+	Color: $ColorGutterHovered;
+}
+
+*.Scrollbar[horizontal] {
+	MinimumSize: 48 0;
+}
+
+*.Scrollbar[vertical] {
+	MinimumSize: 0 48;
+}
+
+*.ScrollbarHandle {
+	Border:      $BorderOuterShadow / 0 1 1 0, $BorderGap / 1, $BorderLifted / 1;
 	Color:       $ColorRaised;
 	MinimumSize: 12;
 }
@@ -137,14 +175,14 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 }
 
 *.Checkbox {
-	Border:      $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Border:      $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
 	Color:       $ColorSunken;
 	Padding:     0 1 1 0;
 	MinimumSize: 19;
 }
 
 *.Checkbox[focused] {
-	Border:  $BorderEngraved, $BorderFocused, $BorderInnerShadow;
+	Border:  $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
 	Color:   $ColorSunkenFocused;
 	Padding: 0;
 }
@@ -177,19 +215,19 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 }
 
 *.TearLine {
-	Border: $BorderTearPad, $BorderTear;
+	Border: $BorderTearPad / 3, $BorderTear / 1;
 }
 
 *.TearLine[hovered] {
-	Border: $BorderTearPadFocused, $BorderTearFocused;
+	Border: $BorderTearPadFocused / 3, $BorderTearFocused / 1;
 }
 
 *.TearLine[focused] {
-	Border: $BorderTearPadFocused, $BorderTearFocused;
+	Border: $BorderTearPadFocused / 3, $BorderTearFocused / 1;
 }
 
 *.Calendar {
-	Border:  $BorderOuterShadow, $BorderGap;
+	Border:  $BorderOuterShadow / 0 1 1 0, $BorderGap / 1;
 	Color:   $ColorRaised;
 	Padding: 2;
 	Gap:     2;
@@ -213,3 +251,69 @@ $BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
 *.CalendarDay[weekend] {
 	Color: $ColorCalendarWeekend;
 }
+
+*.TabbedContainer {
+	Gap: 0;
+}
+
+*.TabRow {
+	Border:  $BorderEngraved / 1 1 0 1, $BorderGap / 1 1 0 1, $BorderInnerShadow / 1 0 0 1;
+	Color:   $ColorSunken;
+	Gap:     0;
+	Padding: 1 0 0 0;
+}
+
+*.Tab {
+	Border:  #0000 / 1 0 0 0, $BorderOuterShadow / 0 1 0 0, $BorderGap / 1 1 0 1, $BorderLifted / 1;
+	Color:   $ColorSunken;
+	Padding: 4 8 2 8;
+}
+
+*.Tab[active] {
+	Border:  $BorderOuterShadow / 0 1 0 0, $BorderGap / 1 1 0 1, $BorderLifted / 1 1 0 1;
+	Color:   $ColorBackground;
+	Padding: 4 8;
+}
+
+*.TabSpacer {
+	Border: $BorderLifted / 0 0 1 0;
+	MinimumSize: 1 0;
+}
+
+*.Swatch {
+	Border:      $BorderEngraved / 1, $BorderGap / 1;
+	Color:       #FFF;
+	MinimumSize: 19;
+}
+
+*.Swatch[focused] {
+	Border: $BorderEngraved / 1, $BorderFocused / 1;
+}
+
+*.ColorPickerMap {
+	Border:      $BorderEngraved / 1, $BorderGap / 1;
+	Color:       $ColorSunken;
+	MinimumSize: 128;
+}
+
+*.Dropdown {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderLifted / 1;
+	Padding: 4 8;
+	Color:   $ColorRaised;
+}
+
+*.Dropdown[focused] {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderLiftedFocused / 1;
+	Padding: 4 8;
+	Color:   $ColorRaisedFocused;
+}
+
+*.Dropdown[hovered] {
+	Color: $ColorRaisedHovered;
+}
+
+*.Dropdown[pressed] {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Padding: 5 8 4 9;
+	Color:   $ColorRaisedPressed;
+}

internal/styles/aluminum/old/aluminum.go

@@ -1,18 +0,0 @@
-package aluminumStyle
-
-import "image/color"
-import "git.tebibyte.media/tomo/tomo"
-
-// New returns Aluminum, a futuristic, bluish-white style.
-func New () *style.Style {
-	return &style.Style {
-		Colors: map[tomo.Color] color.Color {
-			tomo.ColorBackground: colorBackground,
-			tomo.ColorForeground: colorForeground,
-			tomo.ColorRaised:     colorRaised,
-			tomo.ColorSunken:     colorSunken,
-			tomo.ColorAccent:     colorFocus,
-		},
-		Rules: rules,
-	}
-}

internal/styles/aluminum/old/style.go

@@ -1,391 +0,0 @@
-package aluminumStyle
-
-import "image/color"
-import "git.tebibyte.media/tomo/tomo"
-import "golang.org/x/image/font/basicfont"
-
-func hex (color uint32) (c color.RGBA) {
-	c.A = uint8(color)
-	c.B = uint8(color >>  8)
-	c.G = uint8(color >> 16)
-	c.R = uint8(color >> 24)
-	return
-}
-
-func border (top, right, bottom, left uint32, width ...int) tomo.Border {
-	return tomo.Border {
-		Width: tomo.I(width...),
-		Color: [4]color.Color {
-			hex(top),    hex(right),
-			hex(bottom), hex(left),
-		},
-	}
-}
-
-var colorDot                   = hex(0x7391c080)
-var colorFocus                 = hex(0x5f8bc4FF)
-var colorHighlight             = hex(0x5f8bc4FF)
-var colorBackground            = hex(0xd4d4d4FF)
-var colorForeground            = color.Black
-
-var colorOutline               = color.Black
-var colorGutter                = hex(0xbfc6d1FF)
-var colorGutterHovered         = hex(0xc5cbd6FF)
-var colorRaised                = hex(0xe9eaeaFF)
-var colorRaisedPressed         = hex(0xccd4ddFF)
-var colorRaisedFocused         = hex(0xcfd6ddFF)
-var colorRaisedHovered         = hex(0xf1f3f5FF)
-var colorSunken                = hex(0xe9eaeaFF)
-var colorSunkenFocused         = hex(0xe0e6eeFF)
-var colorSunkenPressed         = hex(0xe0e6eeFF)
-var colorCalendarWeekdayHeader = hex(0xd3cac2FF)
-var colorCalendarWeekend       = hex(0xc2d3c4FF)
-var colorCalendarDay           = hex(0xd6dae2FF)
-
-var outline = tomo.Border {
-	Width: tomo.I(1),
-	Color: [4]color.Color {
-		colorOutline,
-		colorOutline,
-		colorOutline,
-		colorOutline,
-	},
-}
-
-var borderEngraved       = border(0xc3c3c5FF, 0xe3e3e3FF, 0xe9e9e9ff, 0xc2c2c2ff, 1)
-var borderGap            = border(0x697c7cFF, 0x566767FF, 0x566767ff, 0x697c7cff, 1)
-var borderLifted         = border(0xf9fafcFF, 0xc2c8d3FF, 0xa4afc0ff, 0xf5f6f8ff, 1)
-var borderLiftedFocused  = border(0xf0f4f9FF, 0xb1bacaFF, 0x9aa6b7ff, 0xe4e9eeff, 1)
-var borderFocused        = border(0x5f8bc4FF, 0x5f8bc4FF, 0x5f8bc4ff, 0x5f8bc4ff, 1)
-var borderTear           = borderEngraved
-var borderTearFocused    = border(0x7f94b5FF, 0xced7e4FF, 0xced7e4FF, 0x7f94b5FF, 1)
-var borderTearPad        = border(0x00000000, 0x00000000, 0x00000000, 0x00000000, 3)
-var borderTearPadFocused = border(0x7391c080, 0x7391c080, 0x7391c080, 0x7391c080, 3)
-var borderInnerShadow    = border(0xa4afc0FF, 0xa4afc0FF, 0xa4afc0ff, 0xa4afc0ff, 1, 0, 0, 1)
-var borderOuterShadow    = border(0xa4afc0FF, 0xa4afc0FF, 0xa4afc0ff, 0xa4afc0ff, 0, 1, 1, 0)
-
-var rules = []style.Rule {
-	// *.*[*]
-	style.Rule {
-		Default: style.AS (
-			style.AttrFace      { Face:  basicfont.Face7x13    },
-			style.AttrTextColor { Color: tomo.ColorForeground  },
-			style.AttrDotColor  { Color: colorDot              },
-			style.AttrGap       { X: 8, Y: 8                   },
-		),
-	},
-
-	// *.Button[*]
-	style.Rule {
-		Role: tomo.R("", "Button", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderLifted,
-			},
-			style.AttrPadding(tomo.I(4, 8)),
-			style.AttrColor { Color: tomo.ColorRaised },
-		),
-		Pressed: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			style.AttrPadding(tomo.I(5, 8, 4, 9)),
-			style.AttrColor { Color: colorRaisedPressed },
-		),
-		Focused: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderLiftedFocused,
-			},
-			style.AttrPadding(tomo.I(4, 8)),
-			style.AttrColor { Color: colorRaisedFocused },
-		),
-		Hovered: style.AS (
-			style.AttrColor { Color: colorRaisedHovered },
-		),
-	},
-
-	// *.TextInput[*]
-	style.Rule {
-		Role: tomo.R("", "TextInput", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			style.AttrColor { Color: tomo.ColorSunken },
-			style.AttrPadding(tomo.I(5, 4, 4, 5)),
-		),
-		Focused: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderFocused,
-				borderInnerShadow,
-			},
-		),
-	},
-
-	// *.TextView[*]
-	style.Rule {
-		Role: tomo.R("", "TextView", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			style.AttrColor { Color: tomo.ColorSunken },
-			style.AttrPadding(tomo.I(8)),
-		),
-	},
-	
-	// *.NumberInput[*]
-	style.Rule {
-		Role: tomo.R("", "NumberInput", ""),
-		Default: style.AS (
-			style.AttrGap { },
-		),
-	},
-
-	// *.Container[sunken]
-	style.Rule {
-		Role: tomo.R("", "Container", "sunken"),
-		Default: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			style.AttrColor { Color: tomo.ColorSunken },
-			style.AttrPadding(tomo.I(8)),
-		),
-	},
-
-	// *.Container[outer]
-	style.Rule {
-		Role: tomo.R("", "Container", "outer"),
-		Default: style.AS (
-			style.AttrColor { Color: tomo.ColorBackground },
-			style.AttrPadding(tomo.I(8)),
-		),
-	},
-
-	// *.Container[menu]
-	style.Rule {
-		Role: tomo.R("", "Container", "menu"),
-		Default: style.AS (
-			style.AttrBorder {
-				borderGap,
-				borderLifted,
-			},
-			style.AttrColor { Color: tomo.ColorBackground },
-			style.AttrGap { },
-		),
-	},
-
-	// *.Heading[*]
-	style.Rule {
-		Role: tomo.R("", "Heading", ""),
-		Default: style.AS (
-			style.AttrAlign { X: tomo.AlignMiddle, Y: tomo.AlignMiddle },
-		),
-	},
-
-	// *.Separator[*]
-	style.Rule {
-		Role: tomo.R("", "Separator", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-			},
-		),
-	},
-
-	// *.Slider[*]
-	style.Rule {
-		Role: tomo.R("", "Slider", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			style.AttrColor { Color: colorGutter },
-		),
-		Focused: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderFocused,
-				borderInnerShadow,
-			},
-		),
-		Hovered: style.AS (
-			style.AttrColor { Color: colorGutterHovered },
-		),
-	},
-	
-	// *.Slider[horizontal]
-	style.Rule {
-		Role: tomo.R("", "Slider", "horizontal"),
-		Default: style.AS(style.AttrMinimumSize { X: 48 }),
-	},
-	
-	// *.Slider[vertical]
-	style.Rule {
-		Role: tomo.R("", "Slider", "vertical"),
-		Default: style.AS(style.AttrMinimumSize { Y: 48 }),
-	},
-
-	// *.SliderHandle[*]
-	style.Rule {
-		Role: tomo.R("", "SliderHandle", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderOuterShadow,
-				borderGap,
-				borderLifted,
-			},
-			style.AttrColor { Color: tomo.ColorRaised },
-			style.AttrMinimumSize { X: 12, Y: 12, },
-		),
-	},
-
-	// *.Checkbox[*]
-	style.Rule {
-		Role: tomo.R("", "Checkbox", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			style.AttrColor { Color: tomo.ColorSunken },
-			style.AttrPadding(tomo.I(0, 1, 1, 0)),
-			style.AttrMinimumSize { X: 19, Y: 19 },
-		),
-		Focused: style.AS (
-			style.AttrBorder {
-				borderEngraved,
-				borderFocused,
-				borderInnerShadow,
-			},
-			style.AttrPadding(tomo.I(0)),
-			style.AttrColor { Color: colorSunkenFocused },
-		),
-	},
-
-	// *.LabelCheckbox[*]
-	style.Rule {
-		Role: tomo.R("", "LabelCheckbox", ""),
-		Default: style.AS (
-			style.AttrGap { X: 8, Y: 8 },
-		),
-	},
-
-	// *.MenuItem[*]
-	style.Rule {
-		Role: tomo.R("", "MenuItem", ""),
-		Default: style.AS (
-			style.AttrPadding(tomo.I(4)),
-			style.AttrGap { X: 4, Y: 4 },
-			style.AttrColor { Color: color.Transparent },
-		),
-		Hovered: style.AS (
-			style.AttrColor { Color: colorDot },
-		),
-		Focused: style.AS (
-			style.AttrColor { Color: colorDot },
-		),
-	},
-
-	// *.File[*]
-	style.Rule {
-		Role: tomo.R("", "File", ""),
-		Default: style.AS (
-			style.AttrColor { Color: color.Transparent },
-		),
-		Focused: style.AS (
-			style.AttrColor { Color: colorDot },
-		),
-	},
-	
-	// *.TearLine[*]
-	style.Rule {
-		Role: tomo.R("", "TearLine", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderTearPad,
-				borderTear,
-			},
-		),
-		Hovered: style.AS (
-			style.AttrBorder {
-				borderTearPadFocused,
-				borderTearFocused,
-			},
-		),
-		Focused: style.AS (
-			style.AttrBorder {
-				borderTearPadFocused,
-				borderTearFocused,
-			},
-		),
-	},
-	
-	// *.Calendar[*]
-	style.Rule {
-		Role: tomo.R("", "Calendar", ""),
-		Default: style.AS (
-			style.AttrBorder {
-				borderOuterShadow,
-				borderGap,
-			},
-			style.AttrColor { Color: tomo.ColorRaised },
-			style.AttrPadding(tomo.I(2)),
-			style.AttrGap { X: 2, Y: 2 },
-		),
-	},
-	
-	// *.CalendarGrid[*]
-	style.Rule {
-		Role: tomo.R("", "CalendarGrid", ""),
-		Default: style.AS (
-			style.AttrGap { X: 2, Y: 2 },
-		),
-	},
-	
-	// *.CalendarWeekdayHeader[*]
-	style.Rule {
-		Role: tomo.R("", "CalendarWeekdayHeader", ""),
-		Default: style.AS (
-			style.AttrPadding(tomo.I(2)),
-			style.AttrColor { Color: colorCalendarWeekdayHeader },
-		),
-	},
-	
-	// *.CalendarDay[weekday]
-	style.Rule {
-		Role: tomo.R("", "CalendarDay", "weekday"),
-		Default: style.AS (
-			style.AttrPadding(tomo.I(2)),
-			style.AttrMinimumSize { X: 32, Y: 32 },
-			style.AttrColor { Color: colorCalendarDay },
-		),
-	},
-
-	// *.CalendarDay[weekend]
-	style.Rule {
-		Role: tomo.R("", "CalendarDay", "weekend"),
-		Default: style.AS (
-			style.AttrPadding(tomo.I(2)),
-			style.AttrMinimumSize { X: 32, Y: 32 },
-			style.AttrColor { Color: colorCalendarWeekend },
-		),
-	},
-}

internal/styles/fallback/wintergreen.go

@@ -61,7 +61,7 @@ func New () (*style.Style, event.Cookie) {
 	atlasTexture := tomo.NewTexture(atlasImage)
 	
 	textureCheckboxChecked  := atlasTexture.SubTexture(image.Rect( 0,  0, 12, 11))
-	textureCorkboard        := atlasTexture.SubTexture(image.Rect(16,  0, 28, 12))
+	// textureCorkboard        := atlasTexture.SubTexture(image.Rect(16,  0, 28, 12))
 	textureTearLine         := atlasTexture.SubTexture(image.Rect(16, 12, 18, 13))
 	textureHandleVertical   := atlasTexture.SubTexture(image.Rect(28,  0, 29,  2))
 	textureHandleHorizontal := atlasTexture.SubTexture(image.Rect(28,  0, 30,  1))
@@ -160,8 +160,8 @@ rules := []style.Rule {
 				Width: tomo.I(1, 0, 0, 1),
 				Color: borderColorEngraved,
 			}),
-		tomo.AColor(nil),
-		tomo.ATexture(textureCorkboard),
+		tomo.AColor(tomo.ColorSunken),
+		// tomo.ATexture(textureCorkboard),
 		tomo.APadding(8),
 	), tomo.R("", "Container"), "sunken"),
 
@@ -188,6 +188,11 @@ rules := []style.Rule {
 	style.Ru(style.AS (
 		tomo.AAlign(tomo.AlignMiddle, tomo.AlignMiddle),
 	), tomo.R("", "Heading")),
+	
+	// *.Heading
+	style.Ru(style.AS (
+		tomo.APadding(4, 8),
+	), tomo.R("", "Heading"), "menu"),
 
 	// *.Separator
 	style.Ru(style.AS (
@@ -258,6 +263,65 @@ rules := []style.Rule {
 		tomo.ATexture(textureHandleHorizontal),
 	), tomo.R("", "SliderHandle"), "horizontal"),
 
+	// *.Scrollbar
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 1),
+				Color: borderColorEngraved,
+			},
+		},
+		tomo.AttrColor { Color: colorGutter },
+		tomo.AttrPadding(tomo.I(0, 1, 1, 0)),
+	), tomo.R("", "Scrollbar")),
+	
+	// *.Scrollbar[focused]
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorFocused,
+			}),
+		tomo.APadding(0),
+	), tomo.R("", "Scrollbar"), "focused"),
+	
+	// *.Scrollbar[horizontal]
+	style.Ru(style.AS (
+		tomo.AMinimumSize(48, 0),
+	), tomo.R("", "Scrollbar"), "horizontal"),
+	
+	// *.Scrollbar[vertical]
+	style.Ru(style.AS (
+		tomo.AMinimumSize(0, 48),
+	), tomo.R("", "Scrollbar"), "vertical"),
+
+	// *.ScrollbarHandle
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorLifted,
+			},
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: [4]color.Color {
+					tomo.ColorRaised, tomo.ColorRaised,
+					tomo.ColorRaised, tomo.ColorRaised,
+				},
+			}),
+		tomo.AColor(nil),
+		tomo.ATexture(textureHandleVertical),
+		tomo.AMinimumSize(12, 12),
+	), tomo.R("", "ScrollbarHandle")),
+
+	// *.ScrollbarHandle[horizontal]
+	style.Ru(style.AS (
+		tomo.ATexture(textureHandleHorizontal),
+	), tomo.R("", "ScrollbarHandle"), "horizontal"),
+
 	// *.ScrollContainer
 	style.Ru(style.AS (
 		tomo.AGap(0, 0),
@@ -498,7 +562,7 @@ rules := []style.Rule {
 				Color: borderColorLifted,
 			},
 		},
-		tomo.AttrPadding(tomo.I(4, 8, 4, 8)),
+		tomo.AttrPadding(tomo.I(4, 8, 7, 8)),
 		tomo.AttrColor { Color: tomo.ColorBackground },
 	), tomo.R("", "Tab"), "active"),
 
@@ -533,6 +597,43 @@ rules := []style.Rule {
 		tomo.AttrColor { Color: tomo.ColorSunken },
 		tomo.AttrMinimumSize { X: 128, Y: 128 },
 	), tomo.R("", "ColorPickerMap")),
+	
+	// *.Dropdown
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorLifted,
+			},
+		},
+		tomo.AttrPadding(tomo.I(4, 8)),
+		tomo.AttrColor { Color: tomo.ColorRaised },
+	), tomo.R("", "Dropdown")),
+
+	// *.Dropdown[focused]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorFocused,
+			},
+		},
+	), tomo.R("", "Dropdown"), "focused"),
+	
+	// *.Dropdown[pressed]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 1),
+				Color: borderColorEngraved,
+			},
+		},
+		tomo.AttrPadding(tomo.I(5, 8, 4, 9)),
+		tomo.AttrColor { Color: colorCarvedPressed },
+	), tomo.R("", "Dropdown"), "pressed"),
 }
 
 	return &style.Style {

internal/styles/tss/parse.go

@@ -133,8 +133,8 @@ func (this *parser) parseSelector () (Selector, error) {
 	// tags
 	err = this.ExpectNext(LBracket)
 	if err == nil {
-		this.Next()
 		for {
+			this.Next()
 			err := this.Expect(Ident, String, RBracket)
 			if err != nil { return Selector { }, err }
 			if this.Is(RBracket) { break       }
@@ -142,6 +142,7 @@ func (this *parser) parseSelector () (Selector, error) {
 			selector.Tags = append(selector.Tags, this.Value())
 			err = this.ExpectNext(Comma, RBracket)
 			if err != nil { return Selector { }, err }
+			if this.Is(RBracket) { break }
 		}
 		this.Next()
 	}

internal/util/util.go

@@ -0,0 +1,10 @@
+package util
+
+import "git.tebibyte.media/tomo/tomo/data"
+
+func GeneralizeXDGIconMimeType (mime data.Mime) data.Mime {
+	// FIXME make this more accurate
+	// https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
+	mime.Subtype = "x-generic"
+	return mime
+}

manager.go

@@ -0,0 +1,33 @@
+package nasin
+
+import "git.tebibyte.media/tomo/tomo"
+import "git.tebibyte.media/tomo/tomo/event"
+
+var manager struct {
+	count int
+}
+
+type funcCookie func ()
+func (cookie funcCookie) Close () {
+	cookie()
+}
+
+// WaitFor ensures that the application will stay running while the given window
+// is open.
+func WaitFor (window tomo.Window) event.Cookie {
+	manager.count ++
+	
+	isManaged := true
+	handleClose := func () {
+		if !isManaged { return }
+		isManaged = false
+		manager.count --
+		if manager.count < 1 {
+			tomo.Stop()
+		}
+	}
+
+	return event.MultiCookie (
+		window.OnClose(handleClose),
+		funcCookie(handleClose))
+}

path.go

@@ -10,12 +10,27 @@ func ApplicationUserDataDir (app ApplicationDescription) (string, error) {
 	return userMkdirAll(app.ID, userDataDir)
 }
 
+// ApplicationSystemDataDirs returns a list of directory paths where an
+// application can look for its system-level data files. These directories may
+// or may not exist. This function may return an empty slice on some platforms.
+func ApplicationSystemDataDirs (app ApplicationDescription) ([]string, error) {
+	return systemDirs(app.ID, systemDataDirs)
+}
+
 // ApplicationUserConfigDir returns the directory path where an application can
 // store its user configuration files.
 func ApplicationUserConfigDir (app ApplicationDescription) (string, error) {
 	return userMkdirAll(app.ID, userConfigDir)
 }
 
+// ApplicationSystemDataDirs returns a list of directory paths where an
+// application can look for its system-level configuration files. These
+// directories may or may not exist. This function may return an empty slice on
+// some platforms.
+func ApplicationSystemConfigDirs (app ApplicationDescription) ([]string, error) {
+	return systemDirs(app.ID, systemConfigDirs)
+}
+
 // ApplicationUserCacheDir returns the directory path where an application can
 // store its user cache files.
 func ApplicationUserCacheDir (app ApplicationDescription) (string, error) {
@@ -30,3 +45,13 @@ func userMkdirAll (sub string, getter func () (string, error)) (string, error) {
 	if err != nil { return "", err }
 	return path, nil
 }
+
+func systemDirs (sub string, getter func () ([]string, error)) ([]string, error) {
+	paths, err := getter()
+	if err != nil { return nil, err }
+	specificPaths := make([]string, len(paths))
+	for index, path := range paths {
+		specificPaths[index] = filepath.Join(path, sub)
+	}
+	return specificPaths, nil
+}

path_unix.go

@@ -7,10 +7,18 @@ func userDataDir () (string, error) {
 	return basedir.DataHome()
 }
 
+func systemDataDirs () ([]string, error) {
+	return basedir.DataDirs()
+}
+
 func userConfigDir () (string, error) {
 	return basedir.ConfigHome()
 }
 
+func systemConfigDirs () ([]string, error) {
+	return basedir.ConfigDirs()
+}
+
 func userCacheDir () (string, error) {
 	return basedir.CacheHome()
 }