Update aluminum theme

...Once we get PageWrapper, that is

README.md

@@ -2,12 +2,79 @@
 
 [![Go Reference](https://pkg.go.dev/badge/git.tebibyte.media/tomo/nasin.svg)](https://pkg.go.dev/git.tebibyte.media/tomo/nasin)
 
-Nasin provides an easy way to write applications with Tomo. To get started, take
+Nasin builds an application framework on top of Tomo to ease and encourage the
-a look at the [examples](examples) directory and the
+development of consistent and stable application software. It has these
+wonderful features, and more:
+
+- Use the Application interface to create applications with relatively low
+  boilerplate
+- CLI argument parsing and URI opening
+- Automatic setup/teardown of the backend
+- Advanced configuration system that can watch config files for changes
+- Default style and icon set, as well as a fully featured stylesheet language
+  for creating custom styles, and support for XDG icon themes
+
+## Getting Started
+Here is a basic "hello world" application, with explanations as comments:
+```go
+package main
+
+import "image"
+import "git.tebibyte.media/tomo/nasin"
+import "git.tebibyte.media/tomo/objects"
+import "git.tebibyte.media/tomo/objects/layouts"
+
+func main () {
+	nasin.RunApplication(new(Application))
+}
+
+type Application struct { }
+
+// Describe returns the application's name and ID, and optionally what type of
+// application it is.
+func (this *Application) Describe () nasin.ApplicationDescription {
+	return nasin.ApplicationDescription {
+		// This is the name of the application. New application windows
+		// will have this as their title by default.
+		Name: "Example",
+		// This is a "well-known" name, which typically is a domain name
+		// owned by the application author.
+		ID: "com.example.Example",
+	}
+}
+
+// Init performs initial setup of the application. Since this is a single-window
+// application that doesn't open any files, we create the window here.
+func (this *Application) Init () error {
+	// Passing an empty rectangle when creating a new window will cause it
+	// to auto-expand to fit the minimum size of its contents.
+	window, err := nasin.NewApplicationWindow(this, image.Rectangle { })
+	if err != nil { return err }
+	// Here we create a new container with a basic vertical layout, place a
+	// text label that says "Hello world!" in it, and set it as the root
+	// object of the window.
+	window.SetRoot(objects.NewOuterContainer (
+		layouts.ContractVertical,
+		objects.NewLabel("Hello world!")))
+	window.SetVisible(true)
+	// Nasin will not exit until all windows it is "waiting for" have
+	// been closed.
+	nasin.WaitFor(window)
+	return nil
+}
+
+// Stop cleanly closes things like system resources or background tasks. We do
+// not have any here, so nothing is done.
+func (this *Application) Stop () { }
+```
+
+To learn more, take a look at the [examples](examples) directory and the
 [online documentation](https://pkg.go.dev/git.tebibyte.media/tomo/nasin).
 
-Related repositories:
+## Related Repositories
 - [Tomo API](https://git.tebibyte.media/tomo/tomo): The API that all other parts
   of the toolkit agree on
 - [Objects](https://git.tebibyte.media/tomo/objects): A standard collection of
   re-usable objects and other GUI components
+- [Backend](https://git.tebibyte.media/tomo/backend): The software responsible
+  for managing and rendering things behind the scenes

application.go

@@ -1,8 +1,15 @@
 package nasin
 
+import "fmt"
 import "log"
+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.
@@ -11,7 +18,39 @@ 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.
+type ApplicationURLOpener interface {
+	Application
+
+	// OpenURL opens a new window with the contents of the given URL. If the
+	// given URL is unsupported, it returns an error (for example, an image
+	// viewer is not expected to open a text file).
+	//
+	// Applications should support the file:// scheme at the very least, and
+	// should also support others like http:// and https:// if possible.
+	OpenURL (*url.URL) error
+
+	// OpenNone is called when the application is launched without any URLs
+	// to open.
+	OpenNone () error
+}
+
+// ApplicationFlagAdder is an application that supports reading command line
+// flags.
+type ApplicationFlagAdder interface {
+	Application
+
+	// AddFlags is called before Init and given the default flag set that
+	// Nasin uses to parse command line arguments. Note that when this
+	// method is called, Tomo will not yet be initialized.
+	AddFlags (*flag.FlagSet)
 }
 
 // ApplicationDescription describes the name and type of an application.
@@ -31,6 +70,15 @@ type ApplicationDescription struct {
 	Role ApplicationRole
 }
 
+// GlobalApplicationDescription returns the global application description which
+// points to cache, data, config, etc. used by Nasin itself.
+func GlobalApplicationDescription () ApplicationDescription {
+	return ApplicationDescription {
+		Name: "Nasin",
+		ID:   "xyz.holanet.Nasin",
+	}
+}
+
 // String satisfies the fmt.Stringer interface.
 func (application ApplicationDescription) String () string {
 	if application.Name == "" {
@@ -76,24 +124,191 @@ type ApplicationRole string; const (
 	RoleChecklist         ApplicationRole = "Checklist"
 )
 
-// RunApplication is like tomo.Run, but runs an application. If something fails
+// Icon returns the icon ID for this role.
-// to initialize, an error is written to the standard logger.
+func (role ApplicationRole) Icon () tomo.Icon {
+	if role == "" {
+		return tomo.IconApplication
+	} else {
+		return tomo.Icon("Application" + strings.ReplaceAll(string(role), " ", ""))
+	}
+}
+
+// RunApplication is like tomo.Run, but runs an application. It automatically
+// sets up a backend. If something fails to initialize, an error is written to
+// the standard logger.
 func RunApplication (application Application) {
-	err := registrar.Init()
+	// TODO: see #4
-	if err != nil { log.Fatal("nasin: could not init registry:", err) }
+
-	err = tomo.Run(func () {
+	if application, ok := application.(ApplicationFlagAdder); ok {
-		err := application.Init()
+		application.AddFlags(flag.CommandLine)
-		if err != nil { log.Fatal("nasin: could not run application:", err) }
+	}
+	flag.Parse()
+
+	// open config
+	globalConfig, err := ApplicationConfig(GlobalApplicationDescription())
+	if err != nil { log.Fatalln("nasin: could not open config:", err) }
+	currentGlobalConfig = globalConfig
+	defer func () {
+		globalConfig.Close()
+		currentGlobalConfig = nil
+	} ()
+	styleConfigKey   := "Style"
+	iconSetConfigKey := "IconSet"
+
+	// registry
+	// TODO: rebuild registry around the config
+	reg := new(registrar.Registrar)
+	backend, err := reg.SetBackend()
+	if err != nil { log.Fatalln("nasin: could not register backend:", err) }
+	err = reg.SetFaceSet()
+	if err != nil { log.Fatalln("nasin: could not set face set:", err) }
+	updateStyle := func () {
+		value, err := globalConfig.GetString(styleConfigKey, "")
+		if err != nil { log.Fatalln("nasin: could not set theme:", err) }
+		err = reg.SetStyle(value)
+		if err != nil { log.Fatalln("nasin: could not set theme:", err) }
+	}
+	updateIconSet := func () {
+		value, err := globalConfig.GetString(iconSetConfigKey, "")
+		if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
+		err = reg.SetIconSet(value)
+		if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
+	}
+	updateStyle()
+	updateIconSet()
+
+	globalConfig.OnChange(func (key string) {
+		switch key {
+		case styleConfigKey:   updateStyle()
+		case iconSetConfigKey: updateIconSet()
+		}
 	})
-	if err != nil { log.Fatal("nasin: could not run application:", err) }
+
+	// init application
+	err = application.Init()
+	if err != nil { log.Fatalln("nasin: could not run application:", err) }
+
+	// open URLs
+	args := flag.Args()
+	applicationOpenUrls(application, args...)
+
+	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
 // automatically set window information to signal to the OS that the window is
-// owned by the application.
+// owned by the application. The window's icon will be automatically set by
-func NewApplicationWindow (application Application, bounds image.Rectangle) (tomo.MainWindow, error) {
+// looking for an icon with the name of the application's ID. If that is not
-	window, err := tomo.NewWindow(bounds)
+// found, the default icon for the application's ApplicationRole will used.
+func NewApplicationWindow (application Application, kind tomo.WindowKind, bounds image.Rectangle) (tomo.Window, error) {
+	window, err := tomo.NewWindow(kind, bounds)
 	if err != nil { return nil, err }
-	window.SetTitle(application.Describe().String())
+	description := application.Describe()
+	window.SetTitle(description.Name)
+
+	setApplicationWindowIcon(window, description)
 	return window, nil
 }
+
+// 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...)
+}
+
+var currentGlobalConfig config.Config
+// GlobalConfig returns the global config. It contains options that apply to
+// Tomo/Nasin itself, such as the style sheet and the icon set. This is managed
+// by Nasin and must not be closed by the application.
+func GlobalConfig () config.Config {
+	return currentGlobalConfig
+}
+
+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()
+				}
+			})
+		}
+	}
+}
+
+func setApplicationWindowIcon (window tomo.Window, description ApplicationDescription) {
+	iconExists := func (icon tomo.Icon) bool {
+		return icon.Texture(tomo.IconSizeMedium) != nil
+	}
+
+	if iconExists(tomo.Icon(description.ID)) {
+		window.SetIcon(tomo.Icon(description.ID))
+		return
+	}
+	if iconExists(description.Role.Icon()) {
+		window.SetIcon(description.Role.Icon())
+		return
+	}
+}

config/README.md

@@ -0,0 +1,78 @@
+# config
+Package config provides a configuration system for applications.
+
+## Config File Location
+Config files are stored in standard operating system locations. Each application
+has exactly one user-level config directory within the user-level config
+location, and a system-level subdirectory in each of the system-level config
+locations (if applicable). Each subdirectory bears the application's well-known
+name as specified in ApplicationDescription. Each subdirectory contains a file
+called config.conf, which is where the actual config data is stored.
+
+The user-level configuration file takes precendence over system configuration
+files, and system configuration files take precedence over eachother depending
+on what order they are specified in. How they are specified depends on the
+operating system.
+
+### Linux, Most Unixes
+In terms of the XDG Base Directory Specification, an application with the
+well-known name com.example.Example would have its config files stored at
+`$XDG_CONFIG_DIRS/com.example.Example/config.conf`. On most systems where this
+specification is applicable, this will result in a file at
+`/etc/xdg/com.example.Example/config.conf` and another at
+`$HOME/.config/com.example.Example/config.conf`. The location for config files
+on systems that do not make use of this specification is yet to be determined.
+
+## Config File Format
+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
+
+### Entries
+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
+- Number
+- Bool
+
+#### String
+A string can be either double-quoted, or any string of runes not identifiable
+as any other kind of value. Quoted strings are always unquoted when they are
+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
+
+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.
+
+#### Number
+A number is a floating point value. It can be of the form:
+- Inf: positive infinity
+- -Inf: negative infinity
+- NaN: "not a number"
+- [0-9]+: a whole number
+- [0-9]+\.[0-9]*: a fractional number
+
+#### Bool
+A bool is a boolean value. It can be one of:
+- true
+- false

config/config.go

@@ -0,0 +1,159 @@
+// 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. Note that calling this behavior
+	// *will* cause a write to disk, and a read from disk for whatever is
+	// watching the user file.
+	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. Note that calling this behavior
+	// *will* cause a write to disk if successful , and a read from disk for
+	// whatever is watching the user file.
+	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,247 @@
+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 }
+
+var _ io.WriterTo = new(File)
+
+// 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. For a description of the format, see the README.md
+// of this package.
+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 }
+	if index, ok := this.keys[key]; ok {
+		if _, ok := this.lines[index].(entry); ok {
+			return true, nil
+		}
+	}
+	return false, 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, ok := 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 }
+	ent := entry {
+		key:   key,
+		value: value,
+	}
+	if index, ok := this.keys[key]; ok {
+		this.lines[index] = ent
+		return nil
+	}
+	this.keys[key] = len(this.lines)
+	this.lines     = append(this.lines, ent)
+	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 {
+		thisEntry, ok := this.lines[index].(entry)
+		if !ok { continue }
+	
+		otherIndex, ok := other.keys[key]
+		if !ok {
+			diff[key] = struct { } { }
+			continue
+		}
+		otherEntry, ok := other.lines[otherIndex].(entry)
+		if !ok {
+			diff[key] = struct { } { }
+			continue
+		}
+		
+		if !thisEntry.value.Equals(otherEntry.value) {
+			diff[key] = struct { } { }
+		}
+	}
+
+	// - keys only they have
+	for key := range other.keys {
+		if otherHas, _ := other.Has(key); !otherHas {
+			continue
+		}
+		if thisHas, _ := this.Has(key); !thisHas {
+			diff[key] = struct { } { }
+		}
+	}
+
+	return diff
+}
+
+// WriteTo writes the data in this file to an io.Writer.
+func (this *File) WriteTo (writer io.Writer) (n int64, err error) {
+	for _, lin := range this.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,222 @@
+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 TestDiffReset (test *testing.T) {
+	file1 := parseFileString(test,
+`key4=0
+key1=value1
+keyToDelete=true
+# comment
+key2=34`)
+	file2 := parseFileString(test,
+`key1=value2
+key2=34
+anotherKeyToDelete=false
+# comment
+
+key3=0.2`)
+	file1.Reset("keyToDelete")
+	file2.Reset("anotherKeyToDelete")
+	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 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,318 @@
+package config
+
+import "os"
+import "log"
+import "sync"
+import "slices"
+import "path/filepath"
+import "github.com/fsnotify/fsnotify"
+import "git.tebibyte.media/tomo/tomo"
+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
+	ignoreNextUserUpdate bool
+
+	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 | fsnotify.Create)) { return }
+	if _, ok := this.paths.watching[event.Name]; !ok  { return }
+
+	if event.Name == this.paths.user {
+		if !this.ignoreNextUserUpdate {
+			previousUser := this.data.user
+			this.reloadUser()
+			newUser := this.data.user
+			this.processUserDiff(newUser.Diff(previousUser))
+		}
+		this.ignoreNextUserUpdate = false
+	} else {
+		index := slices.Index(this.paths.system, event.Name)
+		if index > 0 {
+			previousSystem := this.data.system[index]
+			this.reloadSystem(index)
+			newSystem := this.data.system[index]
+			this.processSystemDiff(index, diffValueMaps(newSystem, previousSystem))
+		}
+	}
+}
+
+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 }
+	this.ignoreNextUserUpdate = true
+	return nil
+}
+
+func (this *config) processUserDiff (changed map[string] struct { }) {
+	for key := range changed {
+		// this is the user file, and nothing has precedence over it, so
+		// the change always matters
+		this.broadcastChange(key)
+	}
+}
+
+func (this *config) processSystemDiff (index int, changed map[string] struct { }) {
+	for key := range changed {
+		// if specified in the user file, the change doesn't matter
+		if this.data.user != nil {
+			if has, _ := this.data.user.Has(key); has {
+				continue
+			}
+		}
+		
+		// if specified in any system files with precedence greater than
+		// this one, the change doesn't matter
+		for _, system := range this.data.system[:index] {
+			if _, has := system[key]; has {
+				continue
+			}
+		}
+
+		// the change does matter
+		this.broadcastChange(key)
+	}
+}
+
+func (this *config) broadcastChange (key string) {
+	for _, listener := range this.on.change.Listeners() {
+		tomo.Do(func () { listener(key) })
+	}
+}
+
+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 }
+	err = this.saveUser()
+	if err != nil { return err }
+	this.broadcastChange(key)
+	return nil
+}
+
+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 }
+	err = this.saveUser()
+	if err != nil { return err }
+	this.broadcastChange(key)
+	return nil
+}
+
+func (this *config) OnChange (callback func (string)) event.Cookie {
+	this.lock.Lock()
+	defer this.lock.Unlock()
+	return this.on.change.Connect(callback)
+}
+
+func diffValueMaps (first, second map[string] Value) map[string] struct { } {
+	diff := make(map[string] struct { })
+	
+	// - keys only first has
+	// - keys both have, but are different
+	for key, firstValue := range first {
+		secondValue, ok := second[key]
+		if !ok {
+			diff[key] = struct { } { }
+			continue
+		}
+		if !firstValue.Equals(secondValue) {
+			diff[key] = struct { } { }
+		}
+	}
+
+	// - keys only second has
+	for key := range second {
+		if _, has := first[key]; !has {
+			diff[key] = struct { } { }
+		}
+	}
+
+	return diff
+}

config/impl_test.go

@@ -0,0 +1,53 @@
+package config
+
+import "maps"
+import "testing"
+
+func TestDiffValueMapsNone (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 := diffValueMaps(file1.Map(), file2.Map())
+	if len(diff) != 0 {
+		test.Fatalf("diff not empty:\n%v", diff)
+	}
+}
+
+func TestDiffValueMaps (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 := diffValueMaps(file1.Map(), file2.Map())
+	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()
+	}
+}
+
+// TODO we need way more tests!
+// need to test watching files. maybe make a temp dir and do it there. remember
+// to defer cleaning up the dir and closing of the config.

examples/clock/main.go

@@ -1,126 +0,0 @@
-// Example clock demonstrates the use of goroutines and tomo.Do() to provide
-// live-updating information.
-package main
-
-import "time"
-import "math"
-import "image"
-import "image/color"
-import "git.tebibyte.media/tomo/tomo"
-import "git.tebibyte.media/tomo/nasin"
-import "git.tebibyte.media/tomo/objects"
-import "git.tebibyte.media/tomo/tomo/canvas"
-import "git.tebibyte.media/tomo/objects/layouts"
-
-type Application struct {
-	clockFace *ClockFace
-	timeLabel *objects.Label
-}
-
-func (this *Application) Describe () nasin.ApplicationDescription {
-	return nasin.ApplicationDescription {
-		Name: "Clock",
-		ID:   "xyz.holanet.TomoClockExample",
-	}
-}
-
-func (this *Application) Init () error {
-	window, err := nasin.NewApplicationWindow(this, image.Rect(0, 0, 128, 160))
-	if err != nil { return err }
-
-	this.clockFace = NewClockFace()
-	this.timeLabel = objects.NewLabel("")
-	this.timeLabel.SetAlign(tomo.AlignMiddle, tomo.AlignMiddle)
-	container := objects.NewOuterContainer (
-		layouts.NewGrid([]bool { true }, []bool { true, false }),
-		this.clockFace,
-		this.timeLabel)
-	window.SetRoot(container)
-
-	go func () {
-		for {
-			tomo.Do(this.updateTime)
-			time.Sleep(time.Second)
-		}
-	} ()
-
-	window.OnClose(tomo.Stop)
-	window.SetVisible(true)
-	return nil
-}
-
-func (this *Application) updateTime () {
-	now := time.Now()
-	this.clockFace.SetTime(now)
-	this.timeLabel.SetText(now.Format(time.DateTime))
-}
-
-func main () {
-	nasin.RunApplication(&Application { })
-}
-
-type ClockFace struct {
-	tomo.CanvasBox
-	time time.Time
-}
-
-func NewClockFace () *ClockFace {
-	box := &ClockFace {
-		CanvasBox: tomo.NewCanvasBox(),
-	}
-	box.SetRole(tomo.R("nasin", "ClockFace", ""))
-	tomo.Apply(box)
-	box.SetDrawer(box)
-	return box
-}
-
-// TODO move ClockFace to objects
-
-func (this *ClockFace) SetTime (when time.Time) {
-	this.time = when
-	this.Invalidate()
-}
-
-func (this *ClockFace) Draw (destination canvas.Canvas) {
-	pen := destination.Pen()
-	pen.Fill(color.Transparent)
-	pen.Rectangle(destination.Bounds())
-
-	for hour := 0; hour < 12; hour ++ {
-		radialLine (
-			destination,
-			tomo.ColorForeground,
-			0.8, 0.9, float64(hour) / 6 * math.Pi)
-	}
-
-	second := float64(this.time.Second())
-	minute := float64(this.time.Minute()) + second / 60
-	hour   := float64(this.time.Hour())   + minute / 60
-
-	radialLine(destination, tomo.ColorForeground, 0, 0.5, (hour   - 3)  / 6  * math.Pi)
-	radialLine(destination, tomo.ColorForeground, 0, 0.7, (minute - 15) / 30 * math.Pi)
-	radialLine(destination, tomo.ColorAccent,     0, 0.7, (second - 15) / 30 * math.Pi)
-}
-
-func radialLine (
-	destination canvas.Canvas,
-	source color.Color,
-	inner  float64,
-	outer  float64,
-	theta  float64,
-) {
-	pen := destination.Pen()
-	bounds := destination.Bounds()
-	width  := float64(bounds.Dx()) / 2
-	height := float64(bounds.Dy()) / 2
-	min := bounds.Min.Add(image.Pt (
-		int(math.Cos(theta) * inner * width + width),
-		int(math.Sin(theta) * inner * height + height)))
-	max := bounds.Min.Add(image.Pt (
-		int(math.Cos(theta) * outer * width + width),
-		int(math.Sin(theta) * outer * height + height)))
-	
-	pen.Stroke(source)
-	pen.StrokeWeight(1)
-	pen.Path(min, max)
-}

examples/icons/main.go

@@ -1,423 +0,0 @@
-// Example icons demonstrates the use of icons, and buttons with icons.
-package main
-
-import "image"
-import "git.tebibyte.media/tomo/tomo"
-import "git.tebibyte.media/tomo/nasin"
-import "git.tebibyte.media/tomo/objects"
-import "git.tebibyte.media/tomo/tomo/input"
-import "git.tebibyte.media/tomo/objects/layouts"
-import "git.tebibyte.media/tomo/nasin/internal/theme/icons/xdg"
-
-const scrollIcons = true
-
-type Application struct {
-	window tomo.MainWindow
-	size   tomo.IconSize
-	grid   tomo.ContainerBox
-}
-
-func (this *Application) Describe () nasin.ApplicationDescription {
-	return nasin.ApplicationDescription {
-		Name: "Tomo Icon Example",
-		ID:   "xyz.holanet.TomoIconExample",
-	}
-}
-
-func (this *Application) Init () error {
-	window, err := nasin.NewApplicationWindow(this, image.Rect(0, 0, 128, 256))
-	if err != nil { return err }
-	this.window = window
-
-	this.grid = objects.NewSunkenContainer(layouts.FlowVertical)
-	this.resizeIcons(tomo.IconSizeSmall)
-	
-	iconButtons := objects.NewInnerContainer(layouts.NewGrid([]bool { true, true, true}, []bool { false }))
-
-	button := objects.NewButton("small")
-	button.SetIcon(tomo.IconZoomOut)
-	button.OnClick(func () { this.resizeIcons(tomo.IconSizeSmall) })
-	iconButtons.Add(button)
-	
-	button = objects.NewButton("medium")
-	button.SetIcon(tomo.IconZoomOriginal)
-	button.OnClick(func () { this.resizeIcons(tomo.IconSizeMedium) })
-	iconButtons.Add(button)
-	
-	button = objects.NewButton("large")
-	button.SetIcon(tomo.IconZoomIn)
-	button.OnClick(func () { this.resizeIcons(tomo.IconSizeLarge) })
-	iconButtons.Add(button)
-	
-	container := objects.NewOuterContainer (
-		layouts.NewGrid([]bool { true }, []bool { false, true, false }),
-		objects.NewLabel("A smorgasbord of icons:"))
-	if scrollIcons {
-		iconScroller := objects.NewScrollContainer(objects.ScrollVertical)
-		this.grid.SetOverflow(false, true)
-		iconScroller.SetRoot(this.grid)
-		container.Add(iconScroller)
-	} else {
-		container.Add(this.grid)
-	}
-	container.Add(iconButtons)
-	window.SetRoot(container)
-
-	window.OnClose(tomo.Stop)
-	window.SetVisible(true)
-	return nil
-}
-
-func (this *Application) resizeIcons (size tomo.IconSize) {
-	this.size = size
-	this.grid.Clear()
-	icons := []tomo.Icon {
-		tomo.IconUnknown,
-		tomo.IconAddressBookNew,
-		tomo.IconApplicationExit,
-		tomo.IconAppointmentNew,
-		tomo.IconCallStart,
-		tomo.IconCallStop,
-		tomo.IconContactNew,
-		tomo.IconDialogOkay,
-		tomo.IconDialogCancel,
-		tomo.IconEditClear,
-		tomo.IconEditCopy,
-		tomo.IconEditCut,
-		tomo.IconEditDelete,
-		tomo.IconEditFind,
-		tomo.IconEditFindReplace,
-		tomo.IconEditPaste,
-		tomo.IconEditRedo,
-		tomo.IconEditSelectAll,
-		tomo.IconEditUndo,
-		tomo.IconFileNew,
-		tomo.IconDirectoryNew,
-		tomo.IconFileOpen,
-		tomo.IconFileOpenRecent,
-		tomo.IconFilePageSetup,
-		tomo.IconFilePrint,
-		tomo.IconFilePrintPreview,
-		tomo.IconFilePermissions,
-		tomo.IconFileProperties,
-		tomo.IconFileRename,
-		tomo.IconFileRevert,
-		tomo.IconFileSave,
-		tomo.IconFileSaveAs,
-		tomo.IconFileSend,
-		tomo.IconFormatIndentLess,
-		tomo.IconFormatIndentMore,
-		tomo.IconFormatAlignCenter,
-		tomo.IconFormatAlignEven,
-		tomo.IconFormatAlignLeft,
-		tomo.IconFormatAlignRight,
-		tomo.IconFormatTextDirectionLtr,
-		tomo.IconFormatTextDirectionRtl,
-		tomo.IconFormatTextBold,
-		tomo.IconFormatTextItalic,
-		tomo.IconFormatTextUnderline,
-		tomo.IconFormatTextStrikethrough,
-		tomo.IconGoBottom,
-		tomo.IconGoDown,
-		tomo.IconGoFirst,
-		tomo.IconGoHome,
-		tomo.IconGoJump,
-		tomo.IconGoLast,
-		tomo.IconGoNext,
-		tomo.IconGoPrevious,
-		tomo.IconGoTop,
-		tomo.IconGoUp,
-		tomo.IconHelpAbout,
-		tomo.IconHelpContents,
-		tomo.IconHelpFaq,
-		tomo.IconInsertImage,
-		tomo.IconInsertLink,
-		tomo.IconInsertObject,
-		tomo.IconInsertText,
-		tomo.IconListAdd,
-		tomo.IconListRemove,
-		tomo.IconMailForward,
-		tomo.IconMailMarkImportant,
-		tomo.IconMailMarkJunk,
-		tomo.IconMailMarkNotJunk,
-		tomo.IconMailMarkRead,
-		tomo.IconMailMarkUnread,
-		tomo.IconMailMessageNew,
-		tomo.IconMailReplyAll,
-		tomo.IconMailReplySender,
-		tomo.IconMailSend,
-		tomo.IconMailReceive,
-		tomo.IconMediaEject,
-		tomo.IconMediaPlaybackPause,
-		tomo.IconMediaPlaybackStart,
-		tomo.IconMediaPlaybackStop,
-		tomo.IconMediaRecord,
-		tomo.IconMediaSeekBackward,
-		tomo.IconMediaSeekForward,
-		tomo.IconMediaSkipBackward,
-		tomo.IconMediaSkipForward,
-		tomo.IconObjectFlipHorizontal,
-		tomo.IconObjectFlipVertical,
-		tomo.IconObjectRotateLeft,
-		tomo.IconObjectRotateRight,
-		tomo.IconProcessStop,
-		tomo.IconSystemLockScreen,
-		tomo.IconSystemLogOut,
-		tomo.IconSystemRun,
-		tomo.IconSystemSearch,
-		tomo.IconSystemReboot,
-		tomo.IconSystemShutdown,
-		tomo.IconToolsCheckSpelling,
-		tomo.IconValueIncrement,
-		tomo.IconValueDecrement,
-		tomo.IconValueReset,
-		tomo.IconViewFullscreen,
-		tomo.IconViewRefresh,
-		tomo.IconViewRestore,
-		tomo.IconViewSortAscending,
-		tomo.IconViewSortDescending,
-		tomo.IconWindowClose,
-		tomo.IconWindowNew,
-		tomo.IconZoomFitBest,
-		tomo.IconZoomIn,
-		tomo.IconZoomOriginal,
-		tomo.IconZoomOut,
-		tomo.IconApplication,
-		tomo.IconApplicationWebBrowser,
-		tomo.IconApplicationMesssanger,
-		tomo.IconApplicationPhone,
-		tomo.IconApplicationMail,
-		tomo.IconApplicationTerminalEmulator,
-		tomo.IconApplicationFileBrowser,
-		tomo.IconApplicationTextEditor,
-		tomo.IconApplicationDocumentViewer,
-		tomo.IconApplicationWordProcessor,
-		tomo.IconApplicationSpreadsheet,
-		tomo.IconApplicationSlideshow,
-		tomo.IconApplicationCalculator,
-		tomo.IconApplicationPreferences,
-		tomo.IconApplicationProcessManager,
-		tomo.IconApplicationSystemInformation,
-		tomo.IconApplicationManual,
-		tomo.IconApplicationCamera,
-		tomo.IconApplicationImageViewer,
-		tomo.IconApplicationMediaPlayer,
-		tomo.IconApplicationImageEditor,
-		tomo.IconApplicationAudioEditor,
-		tomo.IconApplicationVideoEditor,
-		tomo.IconApplicationClock,
-		tomo.IconApplicationCalendar,
-		tomo.IconApplicationChecklist,
-		tomo.IconApplications,
-		tomo.IconApplicationsAccessories,
-		tomo.IconApplicationsDevelopment,
-		tomo.IconApplicationsEngineering,
-		tomo.IconApplicationsGames,
-		tomo.IconApplicationsGraphics,
-		tomo.IconApplicationsInternet,
-		tomo.IconApplicationsMultimedia,
-		tomo.IconApplicationsOffice,
-		tomo.IconApplicationsScience,
-		tomo.IconApplicationsSystem,
-		tomo.IconApplicationsUtilities,
-		tomo.IconPreferences,
-		tomo.IconPreferencesDesktop,
-		tomo.IconPreferencesPeripherals,
-		tomo.IconPreferencesPersonal,
-		tomo.IconPreferencesSystem,
-		tomo.IconPreferencesNetwork,
-		tomo.IconDevice,
-		tomo.IconDeviceCamera,
-		tomo.IconDeviceWebCamera,
-		tomo.IconDeviceComputer,
-		tomo.IconDevicePda,
-		tomo.IconDevicePhone,
-		tomo.IconDevicePrinter,
-		tomo.IconDeviceScanner,
-		tomo.IconDeviceMultimediaPlayer,
-		tomo.IconDeviceVideoDisplay,
-		tomo.IconDeviceAudioInput,
-		tomo.IconDeviceAudioOutput,
-		tomo.IconHardware,
-		tomo.IconHardwareCPU,
-		tomo.IconHardwareGPU,
-		tomo.IconHardwareRAM,
-		tomo.IconHardwareSoundCard,
-		tomo.IconHardwareNetworkAdapter,
-		tomo.IconPowerBattery,
-		tomo.IconStorageHardDisk,
-		tomo.IconStorageFloppyDisk,
-		tomo.IconStorageSolidState,
-		tomo.IconStorageOptical,
-		tomo.IconStorageFlashStick,
-		tomo.IconStorageFlashCard,
-		tomo.IconStorageMagneticTape,
-		tomo.IconInputGaming,
-		tomo.IconInputKeyboard,
-		tomo.IconInputMouse,
-		tomo.IconInputTablet,
-		tomo.IconNetworkWired,
-		tomo.IconNetworkWireless,
-		tomo.IconNetworkCellular,
-		tomo.IconNetworkLocal,
-		tomo.IconNetworkInternet,
-		tomo.IconNetworkVPN,
-		tomo.IconNetworkServer,
-		tomo.IconNetworkWorkgroup,
-		tomo.IconEmblemDefault,
-		tomo.IconEmblemEncrypted,
-		tomo.IconEmblemFavorite,
-		tomo.IconEmblemImportant,
-		tomo.IconEmblemReadOnly,
-		tomo.IconEmblemShared,
-		tomo.IconEmblemSymbolicLink,
-		tomo.IconEmblemSynchronized,
-		tomo.IconEmblemSystem,
-		tomo.IconEmblemUnreadable,
-		tomo.IconPlaceDirectory,
-		tomo.IconPlaceRemote,
-		tomo.IconPlaceHome,
-		tomo.IconPlaceDownloads,
-		tomo.IconPlaceDesktop,
-		tomo.IconPlacePhotos,
-		tomo.IconPlaceBooks,
-		tomo.IconPlaceBookmarks,
-		tomo.IconPlaceTrash,
-		tomo.IconPlaceDocuments,
-		tomo.IconPlaceRepositories,
-		tomo.IconPlaceMusic,
-		tomo.IconPlaceArchives,
-		tomo.IconPlaceFonts,
-		tomo.IconPlaceBinaries,
-		tomo.IconPlaceVideos,
-		tomo.IconPlace3DObjects,
-		tomo.IconPlaceHistory,
-		tomo.IconPlacePreferences,
-		tomo.IconCheckboxChecked,
-		tomo.IconCheckboxUnchecked,
-		tomo.IconAppointmentMissed,
-		tomo.IconAppointmentSoon,
-		tomo.IconDialogError,
-		tomo.IconDialogInformation,
-		tomo.IconDialogPassword,
-		tomo.IconDialogQuestion,
-		tomo.IconDialogWarning,
-		tomo.IconDirectoryDragAccept,
-		tomo.IconDirectoryFull,
-		tomo.IconDirectoryOpen,
-		tomo.IconDirectoryVisiting,
-		tomo.IconTrashFull,
-		tomo.IconResourceLoading,
-		tomo.IconResourceMissing,
-		tomo.IconMailAttachment,
-		tomo.IconMailUnread,
-		tomo.IconMailReplied,
-		tomo.IconMailSigned,
-		tomo.IconMailSignedVerified,
-		tomo.IconCellularSignal0,
-		tomo.IconCellularSignal1,
-		tomo.IconCellularSignal2,
-		tomo.IconCellularSignal3,
-		tomo.IconWirelessSignal0,
-		tomo.IconWirelessSignal1,
-		tomo.IconWirelessSignal2,
-		tomo.IconWirelessSignal3,
-		tomo.IconNetworkError,
-		tomo.IconNetworkIdle,
-		tomo.IconNetworkOffline,
-		tomo.IconNetworkReceive,
-		tomo.IconNetworkTransmit,
-		tomo.IconNetworkTransmitReceive,
-		tomo.IconPrintError,
-		tomo.IconPrintPrinting,
-		tomo.IconSecurityHigh,
-		tomo.IconSecurityMedium,
-		tomo.IconSecurityLow,
-		tomo.IconSoftwareUpdateAvailable,
-		tomo.IconSoftwareUpdateUrgent,
-		tomo.IconSoftwareInstalling,
-		tomo.IconSyncError,
-		tomo.IconSyncSynchronizing,
-		tomo.IconTaskDue,
-		tomo.IconTaskPastDue,
-		tomo.IconUserAvailable,
-		tomo.IconUserAway,
-		tomo.IconUserIdle,
-		tomo.IconUserOffline,
-		tomo.IconBattery0,
-		tomo.IconBattery1,
-		tomo.IconBattery2,
-		tomo.IconBattery3,
-		tomo.IconBrightness0,
-		tomo.IconBrightness1,
-		tomo.IconBrightness2,
-		tomo.IconBrightness3,
-		tomo.IconVolume0,
-		tomo.IconVolume1,
-		tomo.IconVolume2,
-		tomo.IconVolume3,
-		tomo.IconPlaylistRepeat,
-		tomo.IconPlaylistShuffle,
-		tomo.IconWeatherClear,
-		tomo.IconWeatherClearNight,
-		tomo.IconWeatherFewClouds,
-		tomo.IconWeatherFewCloudsNight,
-		tomo.IconWeatherFog,
-		tomo.IconWeatherOvercast,
-		tomo.IconWeatherSevereAlert,
-		tomo.IconWeatherShowers,
-		tomo.IconWeatherShowersScattered,
-		tomo.IconWeatherSnow,
-		tomo.IconWeatherStorm,
-	}
-
-	for _, icon := range icons {
-		iconObject := objects.NewIcon(icon, size)
-		this.grid.Add(iconObject)
-		icon := icon
-		iconObject.OnMouseDown(func (button input.Button) {
-			if button != input.ButtonLeft { return }
-			this.iconPopup(icon)
-		})
-	}
-}
-
-func (this *Application) iconPopup (icon tomo.Icon) error {
-	popup, err := this.window.NewModal(image.Rectangle { })
-	if err != nil { return err }
-
-	if icon == "" {
-		icon = "<UNKNOWN>"
-	}
-
-	sizesRow := objects.NewSunkenContainer (
-		layouts.ContractHorizontal,
-		objects.NewIcon(icon, tomo.IconSizeSmall),
-		objects.NewIcon(icon, tomo.IconSizeMedium),
-		objects.NewIcon(icon, tomo.IconSizeLarge))
-	sizesRow.SetAlign(tomo.AlignMiddle, tomo.AlignMiddle)
-
-	okButton := objects.NewButton("OK")
-	okButton.SetFocused(true)
-	okButton.OnClick(popup.Close)
-	okButton.SetIcon(tomo.IconDialogOkay)
-	controlRow := objects.NewInnerContainer (
-		layouts.ContractHorizontal,
-		okButton)
-	controlRow.SetAlign(tomo.AlignEnd, tomo.AlignMiddle)
-	
-	popup.SetRoot(objects.NewOuterContainer (
-		layouts.NewGrid([]bool { true }, []bool { false, false, true, false }),
-		objects.NewLabel("Icon ID: " + string(icon)),
-		objects.NewLabel("XDG Name: " + xdgIcons.XdgIconName(icon)),
-		sizesRow,
-		controlRow,
-	))
-	popup.SetTitle(string(icon) + ": Properties")
-	popup.SetVisible(true)
-	return nil
-}
-
-func main () {
-	nasin.RunApplication(&Application { })
-}

examples/inputs/main.go

@@ -1,37 +0,0 @@
-// Example inputs demonstrates the use of various user input methods.
-package main
-
-import "image"
-import "git.tebibyte.media/tomo/tomo"
-import "git.tebibyte.media/tomo/nasin"
-import "git.tebibyte.media/tomo/objects"
-import "git.tebibyte.media/tomo/objects/layouts"
-
-type Application struct { }
-
-func (this *Application) Describe () nasin.ApplicationDescription {
-	return nasin.ApplicationDescription {
-		Name: "Tomo Input Example",
-		ID:   "xyz.holanet.TomoInputExample",
-	}
-}
-
-func (this *Application) Init () error {
-	window, err := nasin.NewApplicationWindow(this, image.Rect(0, 0, 128, 128))
-	if err != nil { return err }
-
-	window.SetRoot(objects.NewOuterContainer(layouts.ContractVertical,
-		objects.NewTextInput(""),
-		objects.NewHorizontalSlider(0.5),
-		objects.NewLabelCheckbox(false, "checkbox"),
-		objects.NewNumberInput(5),
-	))
-
-	window.OnClose(tomo.Stop)
-	window.SetVisible(true)
-	return nil
-}
-
-func main () {
-	nasin.RunApplication(&Application { })
-}

examples/license/LICENSE

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

examples/license/main.go

@@ -1,62 +0,0 @@
-// Example license demonstrates the use of a TextView to display licensing 
-// information.
-package main
-
-import "image"
-import _ "embed"
-import "git.tebibyte.media/tomo/tomo"
-import "git.tebibyte.media/tomo/nasin"
-import "git.tebibyte.media/tomo/objects"
-import "git.tebibyte.media/tomo/objects/layouts"
-
-//go:embed LICENSE
-var license []byte
-
-type Application struct { }
-
-func (this *Application) Describe () nasin.ApplicationDescription {
-	return nasin.ApplicationDescription {
-		Name: "Tomo License Example",
-		ID:   "xyz.holanet.TomoLicenseExample",
-	}
-}
-
-func (this *Application) Init () error {
-	window, err := nasin.NewApplicationWindow(this, image.Rect(0, 0, 600, 600))
-	if err != nil { return err }
-
-	checkbox := objects.NewLabelCheckbox(false, "I accept these terms")
-	checkbox.SetFocused(true)
-
-	okButtok := objects.NewButton("OK")
-	okButtok.SetIcon(tomo.IconDialogOkay)
-	okButtok.OnClick(func () {
-		if checkbox.Value() {
-			window.Close()
-		} else {
-			dialog, _ := objects.NewDialogOk (
-				objects.DialogInformation, window,
-				"", "You must read and agree to the license terms", nil)
-			dialog.SetVisible(true)
-		}
-	})
-
-	scroller := objects.NewScrollContainer(objects.ScrollVertical)
-	scroller.SetRoot(objects.NewTextView(string(license)))
-	
-	window.SetRoot(objects.NewOuterContainer (
-		layouts.NewGrid([]bool { true }, []bool { true, false }),
-		scroller,
-		objects.NewInnerContainer (
-			layouts.NewGrid([]bool { true, false }, []bool { true }),
-			checkbox,
-			okButtok)))
-	
-	window.OnClose(tomo.Stop)
-	window.SetVisible(true)
-	return nil
-}
-
-func main () {
-	nasin.RunApplication(&Application { })
-}

go.mod

@@ -1,20 +1,24 @@
 module git.tebibyte.media/tomo/nasin
 
-go 1.20
+go 1.22.2
 
 require (
-	git.tebibyte.media/tomo/backend v0.2.0
+	git.tebibyte.media/sashakoshka/goparse v0.2.0
-	git.tebibyte.media/tomo/objects v0.16.0
+	git.tebibyte.media/tomo/backend v0.8.0
-	git.tebibyte.media/tomo/tomo v0.35.0
+	git.tebibyte.media/tomo/objects v0.24.0
+	git.tebibyte.media/tomo/tomo v0.48.0
 	git.tebibyte.media/tomo/xdg v0.1.0
+	github.com/fsnotify/fsnotify v1.7.0
 	golang.org/x/image v0.11.0
 )
 
 require (
-	git.tebibyte.media/tomo/typeset v0.7.1 // indirect
+	git.tebibyte.media/sashakoshka/goutil v0.3.1 // indirect
+	git.tebibyte.media/tomo/typeset v0.8.0 // indirect
 	git.tebibyte.media/tomo/xgbkb v1.0.1 // indirect
 	github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298 // indirect
 	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,16 @@
+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/goutil v0.3.1 h1:zvAMKS+aea96q6oTttCWfNLXqOHisI3IKAwX6BWKfY0=
+git.tebibyte.media/sashakoshka/goutil v0.3.1/go.mod h1:Yo/M2sbi9IbzZCFsEj8/Fg7sNwHkDaJ6saTHOha+Dow=
 git.tebibyte.media/sashakoshka/xgbkb v1.0.0/go.mod h1:pNcE6TRO93vHd6q42SdwLSTTj25L0Yzggz7yLe0JV6Q=
-git.tebibyte.media/tomo/backend v0.2.0 h1:9vMQxIRnfzyMVGP3wBTz9qoWzSwLcCYzKIogikk05a0=
+git.tebibyte.media/tomo/backend v0.8.0 h1:mPP6g60lL7v9GOjyUl/oGkHK/CV4ZJB8OUlw0E7WEhk=
-git.tebibyte.media/tomo/backend v0.2.0/go.mod h1:os77Uo/YkQ9EmNZK8U1ljsEUkTK36P27dKmp5p8TMeE=
+git.tebibyte.media/tomo/backend v0.8.0/go.mod h1:yIWW8XXDsaHfIhAuxg336oYlgX0uCn3lwgaydh8BagE=
-git.tebibyte.media/tomo/objects v0.16.0 h1:Q/w8yHZepj0ESYtPGvWtXxZXkTU+k03rfPxvoxXU5AQ=
+git.tebibyte.media/tomo/objects v0.24.0 h1:O91CxHJ1eA5/WJzDNm46lTA3Lm6t1CrLtf8gLKtuX7U=
-git.tebibyte.media/tomo/objects v0.16.0/go.mod h1:jRRpraLGpBzwiOv6kl1Ram229BpJZxJaS4eqIhze194=
+git.tebibyte.media/tomo/objects v0.24.0/go.mod h1:atTxG2mRqDQBFS/0KoqP9VR50BozFLi7XRz/AkFJtMo=
-git.tebibyte.media/tomo/tomo v0.35.0 h1:1XvcUcWg1rBZXov3KfuX6VfiuBQ2mcJHIslHMLn07no=
+git.tebibyte.media/tomo/tomo v0.48.0 h1:AE21ElHwUSPsX82ZWCnoNxJFi9Oswyd3dPDPMbxTueQ=
-git.tebibyte.media/tomo/tomo v0.35.0/go.mod h1:C9EzepS9wjkTJjnZaPBh22YvVPyA4hbBAJVU20Rdmps=
+git.tebibyte.media/tomo/tomo v0.48.0/go.mod h1:WrtilgKB1y8O2Yu7X4mYcRiqOlPR8NuUnoA/ynkQWrs=
-git.tebibyte.media/tomo/typeset v0.7.1 h1:aZrsHwCG5ZB4f5CruRFsxLv5ezJUCFUFsQJJso2sXQ8=
+git.tebibyte.media/tomo/typeset v0.8.0 h1:4qA6oW4/3oPHj6/Zrp+JFJ53OmFSDvxs+J6BhO3DW00=
-git.tebibyte.media/tomo/typeset v0.7.1/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
+git.tebibyte.media/tomo/typeset v0.8.0/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
 git.tebibyte.media/tomo/xdg v0.1.0 h1:6G2WYPPiM2IXleCpKKHuJA34BxumwNWuLsUoX3yu5zA=
 git.tebibyte.media/tomo/xdg v0.1.0/go.mod h1:tuaRwRkyYW7mqlxA7P2+V+e10KzcamNoUzcOgaIYKAY=
 git.tebibyte.media/tomo/xgbkb v1.0.1 h1:b3HDUopjdQp1MZrb5Vpil4bOtk3NnNXtfQW27Blw2kE=
@@ -15,6 +19,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=
@@ -40,6 +46,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/faces/fallback/face.go

@@ -0,0 +1,35 @@
+package fallbackFaces
+
+import "golang.org/x/image/font"
+import "git.tebibyte.media/tomo/tomo"
+import "golang.org/x/image/font/basicfont"
+import "git.tebibyte.media/tomo/backend/style"
+
+type faceSet struct {
+	regular    font.Face
+	bold       font.Face
+	italic     font.Face
+	boldItalic font.Face
+}
+
+// New creates a new fallback face set.
+func New () style.FaceSet {
+	// TODO maybe pre-generate different variations of this face
+	return &faceSet {
+		regular:    basicfont.Face7x13,
+		bold:       basicfont.Face7x13,
+		italic:     basicfont.Face7x13,
+		boldItalic: basicfont.Face7x13,
+	}
+}
+
+func (this *faceSet) Face (face tomo.Face) font.Face {
+	bold   := face.Weight >= 500
+	italic := face.Italic >= 0.1 || face.Slant >= 0.1
+	switch {
+	case bold && italic: return this.boldItalic
+	case bold:           return this.bold
+	case italic:         return this.italic
+	default:             return this.regular
+	}
+}

internal/icons/fallback/assets/README.md

@@ -0,0 +1,7 @@
+# assets
+These are the assets for the fallback (Wintergreen) icon set. When making edits
+to these icons, open both the png and xcf files. When you wish to save your
+changes, delete the contents of the png file and paste in the "Icons" layer of
+the xcf file, then export the png file and save the xcf file. This is because
+the exported pngs use indexed color to save space as they are embedded into
+application binaries.

internal/icons/fallback/icon.go

@@ -6,15 +6,37 @@ import _ "embed"
 import _ "image/png"
 import "git.tebibyte.media/tomo/tomo"
 import "git.tebibyte.media/tomo/tomo/data"
+import "git.tebibyte.media/tomo/tomo/event"
 import "git.tebibyte.media/tomo/tomo/canvas"
-import dataTheme "git.tebibyte.media/tomo/nasin/internal/theme"
+import "git.tebibyte.media/tomo/backend/style"
+import "git.tebibyte.media/tomo/nasin/internal/util"
 
 //go:embed assets/icons-small.png
 var atlasSmallBytes []byte
 //go:embed assets/icons-large.png
 var atlasLargeBytes []byte
 
-func generateSource (data []byte, width int) map[tomo.Icon] canvas.Texture {
+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) (canvas.TextureCloser, map[tomo.Icon] canvas.Texture) {
 	atlasImage, _, err := image.Decode(bytes.NewReader(data))
 	if err != nil { panic(err) }
 	atlasTexture := tomo.NewTexture(atlasImage)
@@ -37,7 +59,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 +149,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 +354,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)
@@ -409,26 +449,29 @@ func generateSource (data []byte, width int) map[tomo.Icon] canvas.Texture {
 	col(tomo.IconWeatherSnow)
 	col(tomo.IconWeatherStorm)
 	
-	return source
+	return atlasTexture, source
 }
 
-type iconTheme struct {
+type iconSet struct {
+	atlasSmall canvas.TextureCloser
+	atlasLarge canvas.TextureCloser
 	texturesSmall map[tomo.Icon] canvas.Texture
 	texturesLarge map[tomo.Icon] canvas.Texture
 }
 
-// New creates a new fallback icon theme.
+// New creates a new fallback icon set.
-func New () dataTheme.IconTheme {
+func New () (style.IconSet, event.Cookie) {
-	return new(iconTheme)
+	iconSet := new(iconSet)
+	return iconSet, iconSet
 }
 
-func (this *iconTheme) ensure () {
+func (this *iconSet) ensure () {
 	if this.texturesSmall != nil { return }
-	this.texturesSmall = generateSource(atlasSmallBytes, 16)
+	this.atlasSmall, this.texturesSmall = generateSource(atlasSmallBytes, 16)
-	this.texturesLarge = generateSource(atlasLargeBytes, 32)
+	this.atlasLarge, this.texturesLarge = generateSource(atlasLargeBytes, 32)
 }
 
-func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.Texture {
+func (this *iconSet) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.Texture {
 	if size == tomo.IconSizeSmall {
 		return this.texturesSmall
 	} else {
@@ -436,7 +479,7 @@ func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.T
 	}
 }
 
-func (this *iconTheme) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
+func (this *iconSet) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
 	this.ensure()
 	source := this.selectSource(size)
 	if texture, ok := source[icon]; ok {
@@ -445,12 +488,29 @@ func (this *iconTheme) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture
 	return nil
 }
 
-func (this *iconTheme) MimeIcon (mime data.Mime, 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)]
 	}
 }
+
+func (this *iconSet) Close () error {
+	if this.atlasSmall != nil {
+		this.atlasSmall.Close()
+	}
+	if this.atlasLarge != nil {
+		this.atlasLarge.Close()
+	}
+	return nil
+}

internal/icons/xdg/icon.go

@@ -8,35 +8,37 @@ import "regexp"
 import "strings"
 import _ "image/png"
 import "git.tebibyte.media/tomo/tomo"
-import xdgIconTheme "git.tebibyte.media/tomo/xdg/icon-theme"
 import "git.tebibyte.media/tomo/tomo/data"
+import "git.tebibyte.media/tomo/tomo/event"
 import "git.tebibyte.media/tomo/tomo/canvas"
-import "git.tebibyte.media/tomo/nasin/internal/theme"
+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 {
 	xdg xdgIconTheme.Theme
-	fallback       theme.IconTheme
+	fallback       style.IconSet
-	texturesSmall  map[tomo.Icon] canvas.Texture
+	texturesSmall  map[tomo.Icon] canvas.TextureCloser
-	texturesMedium map[tomo.Icon] canvas.Texture
+	texturesMedium map[tomo.Icon] canvas.TextureCloser
-	texturesLarge  map[tomo.Icon] canvas.Texture
+	texturesLarge  map[tomo.Icon] canvas.TextureCloser
 }
 
-func FindThemeWarn (name string, fallback theme.IconTheme, path ...string) (theme.IconTheme, error) {
+func FindThemeWarn (name string, fallback style.IconSet, path ...string) (style.IconSet, event.Cookie, error) {
 	this := &iconTheme {
 		fallback:       fallback,
-		texturesLarge:  make(map[tomo.Icon] canvas.Texture),
+		texturesLarge:  make(map[tomo.Icon] canvas.TextureCloser),
-		texturesMedium: make(map[tomo.Icon] canvas.Texture),
+		texturesMedium: make(map[tomo.Icon] canvas.TextureCloser),
-		texturesSmall:  make(map[tomo.Icon] canvas.Texture),
+		texturesSmall:  make(map[tomo.Icon] canvas.TextureCloser),
 	}
 	
 	xdg, err := xdgIconTheme.FindThemeWarn(name, path...)
-	if err != nil { return nil, err }
+	if err != nil { return nil, nil, err }
 	this.xdg = xdg
 	
-	return this, nil
+	return this, this, nil
 }
 
-func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.Texture {
+func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.TextureCloser {
 	switch size {
 	case tomo.IconSizeMedium: return this.texturesMedium
 	case tomo.IconSizeLarge:  return this.texturesLarge
@@ -44,7 +46,7 @@ func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.T
 	}
 }
 
-func (this *iconTheme) xdgIcon (name string, size tomo.IconSize) (canvas.Texture, bool) {
+func (this *iconTheme) xdgIcon (name string, size tomo.IconSize) (canvas.TextureCloser, bool) {
 	// TODO use scaling factor instead of 1
 	// find icon file
 	icon, err := this.xdg.FindIcon(name, iconSizePixels(size), 1, xdgIconTheme.PNG)
@@ -99,7 +101,21 @@ func (this *iconTheme) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Text
 	}
 }
 
-func (this *iconTheme) icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
+func (this *iconTheme) Close () error {
+	closeAllIn := func (mp map[tomo.Icon] canvas.TextureCloser) {
+		for _, texture := range mp {
+			if texture != nil {
+				texture.Close()
+			}
+		}
+	}
+	closeAllIn(this.texturesSmall)
+	closeAllIn(this.texturesMedium)
+	closeAllIn(this.texturesLarge)
+	return nil
+}
+
+func (this *iconTheme) icon (icon tomo.Icon, size tomo.IconSize) canvas.TextureCloser {
 	if texture, ok := this.xdgIcon(XdgIconName(icon), size); ok {
 		return texture
 	}
@@ -109,11 +125,11 @@ func (this *iconTheme) icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture
 	return nil
 }
 
-func (this *iconTheme) mimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
+func (this *iconTheme) mimeIcon (mime data.Mime, size tomo.IconSize) canvas.TextureCloser {
 	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 +182,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/registrar/registrar_unix.go

@@ -1,38 +1,82 @@
 //go:build unix && (!darwin)
 package registrar
 
-import "os"
 import "log"
-import "git.tebibyte.media/tomo/backend/x"
 import "git.tebibyte.media/tomo/tomo"
-import dataTheme "git.tebibyte.media/tomo/nasin/internal/theme"
+import "git.tebibyte.media/tomo/backend/x"
-import "git.tebibyte.media/tomo/nasin/internal/theme/icons/xdg"
+import "git.tebibyte.media/tomo/tomo/event"
-import "git.tebibyte.media/tomo/nasin/internal/theme/icons/fallback"
+import "git.tebibyte.media/sashakoshka/goparse"
-import "git.tebibyte.media/tomo/nasin/internal/theme/style/fallback"
+import "git.tebibyte.media/tomo/nasin/internal/icons/xdg"
-import "git.tebibyte.media/tomo/nasin/internal/theme/style/aluminum"
+import "git.tebibyte.media/tomo/nasin/internal/styles/tss"
+import "git.tebibyte.media/tomo/nasin/internal/icons/fallback"
+import "git.tebibyte.media/tomo/nasin/internal/styles/fallback"
+import "git.tebibyte.media/tomo/nasin/internal/faces/fallback"
 
-func Init () error {
+type Registrar struct {
-	var theme *dataTheme.Theme
+	backend *x.Backend
-	// TODO eventually get rid of this when we make a file format for
+	iconSetCookie event.Cookie
-	// storing visual styles
+	styleCookie   event.Cookie
-	if os.Getenv("TOMO_USE_ALUMINUM_STYLE") != "" {
+}
-		theme = aluminumStyle.New()
+
-	} else {
+func (this *Registrar) SetBackend () (tomo.Backend, error) {
-		theme = fallbackStyle.New()
+	backend, err := x.New()
+	if err != nil { return nil, err }
+	this.backend = backend.(*x.Backend)
+	tomo.SetBackend(backend)
+	return backend, nil
+}
+
+func (this *Registrar) SetStyle (name string) error {
+	if this.styleCookie != nil {
+		this.styleCookie.Close()
+		this.styleCookie = nil
 	}
-	theme.IconTheme = fallbackIcons.New()
+
-	
+	if name != "" {
-	iconThemeName := os.Getenv("TOMO_XDG_ICON_THEME")
+		styl, cookie, err := tss.LoadFile(name)
-	if iconThemeName != "" {
-		iconTheme, err := xdgIcons.FindThemeWarn(iconThemeName, theme.IconTheme)
 		if err == nil {
-			theme.IconTheme = iconTheme
+			this.backend.SetStyle(styl)
+			this.styleCookie = cookie
+			return nil
 		} else {
-			log.Printf("nasin: could not load icon theme '%s': %v", iconThemeName, err)
+			log.Printf (
+				"nasin: could not load style sheet '%s'\n%v",
+				name, parse.Format(err))
 		}
 	}
 	
-	tomo.SetTheme(theme)
+	styl, cookie := fallbackStyle.New()
-	tomo.Register(1, x.New)
+	this.styleCookie = cookie
+	this.backend.SetStyle(styl)
+	return nil
+}
+
+func (this *Registrar) SetIconSet (name string) error {
+	if this.iconSetCookie != nil {
+		this.iconSetCookie.Close()
+		this.iconSetCookie = nil
+	}
+	
+	iconSet, cookie := fallbackIcons.New()
+	if name != "" {
+		xdgIconSet, xdgCookie, err := xdgIcons.FindThemeWarn(name, iconSet)
+		cookie = event.MultiCookie(cookie, xdgCookie)
+		if err == nil {
+			iconSet = xdgIconSet
+		} else {
+			log.Printf("nasin: could not load icon theme '%s': %v", name, err)
+		}
+	}
+	
+	this.backend.SetIconSet(iconSet)
+	this.iconSetCookie = cookie
+	return nil
+}
+
+func (this *Registrar) SetFaceSet () error {
+	// TODO replace this with something that uses findfont, and caches and
+	// refcounts the faces
+	faceSet := fallbackFaces.New()
+	this.backend.SetFaceSet(faceSet)
 	return nil
 }

internal/styles/aluminum/aluminum.tss

@@ -0,0 +1,331 @@
+// Colors
+$ColorDot                   = #7391c080;
+$ColorAccent                = #5f8bc4;
+$ColorHighlight             = #5f8bc4;
+$ColorBackground            = #d4d4d4;
+$ColorForeground            = #000;
+$ColorOutline               = $ColorForeground;
+$ColorGutter                = #bfc6d1;
+$ColorGutterHovered         = #c5cbd6;
+$ColorRaised                = #e9eaea;
+$ColorRaisedPressed         = #ccd4dd;
+$ColorRaisedFocused         = #cfd6dd;
+$ColorRaisedHovered         = #f1f3f5;
+$ColorSunken                = #e9eaea;
+$ColorSunkenFocused         = #e0e6ee;
+$ColorSunkenPressed         = #e0e6ee;
+$ColorCalendarWeekdayHeader = #d3cac2;
+$ColorCalendarWeekend       = #c2d3c4;
+$ColorCalendarDay           = #d6dae2;
+$ColorOptionSegment         = #c6c8cc;
+
+// Borders
+$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                        ;
+$BorderOptionSegment  = #b0b6c0                        ;
+
+*.* {
+	TextColor: $ColorForeground;
+	DotColor:  $ColorDot;
+	Gap:       8;
+}
+
+*.Button {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderLifted / 1;
+	Padding: 4 8;
+	Color:   $ColorRaised;
+}
+
+*.Button[focused] {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderLiftedFocused / 1;
+	Padding: 4 8;
+	Color:   $ColorRaisedFocused;
+}
+
+*.Button[hovered] {
+	Color: $ColorRaisedHovered;
+}
+
+*.Button[pressed] {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Padding: 5 8 4 9;
+	Color:   $ColorRaisedPressed;
+}
+
+*.TextInput {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Padding: 5 4 4 5;
+	Color:   $ColorSunken;
+}
+
+*.TextInput[focused] {
+	Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
+}
+
+*.TextView {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Padding: 5 4 4 5;
+	Color:   $ColorSunken;
+}
+
+*.NumberInput {
+	Gap: 0;
+}
+
+*.Heading {
+	Align: middle middle;
+}
+
+*.Heading[menu] {
+	Align:   middle middle;
+	Padding: 4 8;
+}
+
+*.Pegboard {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Padding: 5 4 4 5;
+	Color:   $ColorSunken;
+}
+
+*.Segment {
+	Padding: 8;
+}
+
+*.Segment[command] {
+	Padding: 8 8 0 8;
+}
+
+*.Segment[status] {
+	Color:  $ColorOptionSegment;
+	Border: $BorderOptionSegment / 1 0 0 0;
+}
+
+*.Segment[option] {
+	Color:  $ColorOptionSegment;
+	Border: $BorderOptionSegment / 1 0 0 0;
+}
+
+*.Separator {
+	Border: $BorderEngraved / 1;
+}
+
+*.Slider {
+	Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Color:  $ColorGutter;
+}
+
+*.Slider[focused] {
+	Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
+}
+
+*.Slider[hovered] {
+	Color: $ColorGutterHovered;
+}
+
+*.Slider[horizontal] {
+	MinimumSize: 48 0;
+}
+
+*.Slider[vertical] {
+	MinimumSize: 0 48;
+}
+
+*.SliderHandle {
+	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;
+}
+
+*.ScrollContainer {
+	Gap: 0;
+}
+
+*.Checkbox {
+	Border:      $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Color:       $ColorSunken;
+	Padding:     0 1 1 0;
+	MinimumSize: 19;
+}
+
+*.Checkbox[focused] {
+	Border:  $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
+	Color:   $ColorSunkenFocused;
+	Padding: 0;
+}
+
+*.Checkbox[checked] {
+	Texture:     "assets/checkbox-checked.png";
+	TextureMode: center;
+}
+
+*.MenuItem {
+	Padding: 4;
+	Gap:     4;
+	Color:   #0000;
+}
+
+*.MenuItem[focused] {
+	Color: $ColorDot;
+}
+
+*.File {
+	Color: #0000;
+}
+
+*.File[focused] {
+	Color: $ColorDot;
+}
+
+*.TearLine {
+	Border: $BorderTearPad / 3, $BorderTear / 1;
+}
+
+*.TearLine[focused] {
+	Border: $BorderTearPadFocused / 3, $BorderTearFocused / 1;
+}
+
+*.Calendar {
+	Border:  $BorderOuterShadow / 0 1 1 0, $BorderGap / 1;
+	Color:   $ColorRaised;
+	Padding: 2;
+	Gap:     2;
+}
+
+*.CalendarGrid {
+	Gap: 2 2;
+}
+
+*.CalendarWeekdayHeader {
+	Color:   $ColorCalendarWeekdayHeader;
+	Padding: 2;
+}
+
+*.CalendarDay {
+	Color:       $ColorCalendarDay;
+	Padding:     2;
+	MinimumSize: 32;
+}
+
+*.CalendarDay[weekend] {
+	Color: $ColorCalendarWeekend;
+}
+
+*.Root {
+	Color:  $ColorBackground;
+	Gap:    0;
+}
+
+*.Root[menu] {
+	Border: $BorderGap / 1, $BorderLifted / 1;
+	Color:  $ColorBackground;
+	Gap:    0;
+}
+
+*.Root[menu, torn] {
+	Border: ;
+	Color:  $ColorBackground;
+	Gap:    0;
+}
+
+*.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/fallback/wintergreen.go

@@ -0,0 +1,632 @@
+package fallbackStyle
+
+import "bytes"
+import "image"
+import _ "embed"
+import _ "image/png"
+import "image/color"
+import "git.tebibyte.media/tomo/tomo"
+import "git.tebibyte.media/tomo/tomo/event"
+import "git.tebibyte.media/tomo/backend/style"
+
+// Note: these are color.RGBA values. Remember alpha premultiplication.
+
+var colorTransparent           = color.RGBA {                         A: 0   }
+var colorFocus                 = color.RGBA { R:  61, G: 128, B: 143, A: 255 }
+var colorInput                 = color.RGBA { R: 208, G: 203, B: 150, A: 255 }
+var colorCarved                = color.RGBA { R: 151, G: 160, B: 150, A: 255 }
+var colorGutter                = color.RGBA { R: 116, G: 132, B: 126, A: 255 }
+var colorShadow                = color.RGBA { R:  57, G:  59, B:  57, A: 255 }
+var colorShade                 = color.RGBA {                         A: 128 }
+var colorInputShadow           = color.RGBA { R: 143, G: 146, B:  91, A: 255 }
+var colorHighlight             = color.RGBA { R: 207, G: 215, B: 210, A: 255 }
+var colorBackground            = color.RGBA { R: 169, G: 171, B: 168, A: 255 }
+var colorCarvedPressed         = color.RGBA { R: 129, G: 142, B: 137, A: 255 }
+var colorForeground            = color.Black
+var colorOutline               = color.Black
+var colorCalendarWeekdayHeader = color.RGBA { R: 194, G: 162, B: 132, A: 255 }
+var colorCalendarWeekend       = color.RGBA { R: 165, G: 185, B: 120, A: 255 }
+var colorCalendarDay           = color.RGBA { R: 194, G: 189, B: 132, A: 255 }
+var colorInactive              = color.RGBA { R: 131, G: 147, B: 134, A: 255 }
+
+var outline = tomo.Border {
+	Width: tomo.I(1),
+	Color: [4]color.Color {
+		colorOutline,
+		colorOutline,
+		colorOutline,
+		colorOutline,
+	},
+}
+
+var borderColorOutline  = [4]color.Color { colorOutline,     colorOutline,   colorOutline,   colorOutline     }
+var borderColorEngraved = [4]color.Color { colorShadow,      colorHighlight, colorHighlight, colorShadow      }
+var borderColorLifted   = [4]color.Color { colorHighlight,   colorShadow,    colorShadow,    colorHighlight   }
+var borderColorInput    = [4]color.Color { colorInputShadow, colorInput,     colorInput,     colorInputShadow }
+var borderColorFocused  = [4]color.Color { colorFocus,       colorFocus,     colorFocus,     colorFocus       }
+var borderColorShade    = [4]color.Color { colorShade,       colorShade,     colorShade,     colorShade       }
+
+//go:embed assets/atlas.png
+var atlasBytes []byte
+
+// New returns Wintergreen, the default Tomo style. It is neutral-gray with
+// green and turquoise accents.
+func New () (*style.Style, event.Cookie) {
+	atlasImage, _, err := image.Decode(bytes.NewReader(atlasBytes))
+	if err != nil { panic(err) }
+	atlasTexture := tomo.NewTexture(atlasImage)
+	
+	textureCheckboxChecked  := atlasTexture.SubTexture(image.Rect( 0,  0, 12, 11))
+	// 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))
+
+	cookie := event.MultiCookie(atlasTexture)
+
+rules := []style.Rule {
+	// *.*
+	style.Ru(style.AS (
+		tomo.ATextColor (tomo.ColorForeground),
+		tomo.ADotColor  (tomo.ColorAccent    ),
+		tomo.AGap       (8, 8                ),
+	), tomo.R("", "")),
+
+	// *.Button
+	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("", "Button")),
+
+	// *.Button[focused]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorFocused,
+			},
+		},
+	), tomo.R("", "Button"), "focused"),
+	
+	// *.Button[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("", "Button"), "pressed"),
+
+	// *.TextInput
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorInput,
+			}),
+		tomo.AColor(colorInput),
+		tomo.APadding(5, 4, 4, 5),
+	), tomo.R("", "TextInput")),
+
+	// *.TextInput[focused]
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorFocused,
+			}),
+	), tomo.R("", "TextInput"), "focused"),
+	
+	// *.TextView
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 1),
+				Color: borderColorEngraved,
+			}),
+		tomo.AColor(tomo.ColorSunken),
+		tomo.APadding(8),
+	), tomo.R("", "TextView")),
+	
+	// *.NumberInput
+	style.Ru(style.AS (
+		tomo.AGap(0, 0),
+	), tomo.R("", "NumberInput")),
+
+	// *.Root
+	style.Ru(style.AS (
+		tomo.AGap(0, 0),
+	), tomo.R("", "Root")),
+
+	// *.Root[menu]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorLifted,
+			},
+		},
+		tomo.AttrColor { Color: tomo.ColorBackground },
+		tomo.AttrGap { },
+	), tomo.R("", "Root"), "menu"),
+
+	// *.Pegboard
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 1),
+				Color: borderColorEngraved,
+			}),
+		tomo.AColor(tomo.ColorSunken),
+		// tomo.ATexture(textureCorkboard),
+		tomo.APadding(8),
+	), tomo.R("", "Pegboard")),
+
+	// *.Segment
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorLifted,
+			},
+		},
+		tomo.AttrColor { Color: tomo.ColorBackground },
+		tomo.AttrPadding(tomo.I(8)),
+	), tomo.R("", "Segment")),
+
+	// *.Segment[option]
+	style.Ru(style.AS (
+		tomo.AttrColor { Color: tomo.ColorSunken },
+		tomo.AttrPadding(tomo.I(8)),
+	), tomo.R("", "Segment"), "option"),
+
+	// *.Heading
+	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 (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorEngraved,
+			},
+		},
+	), tomo.R("", "Separator")),
+
+	// *.Slider
+	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("", "Slider")),
+	
+	// *.Slider[focused]
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorFocused,
+			}),
+		tomo.APadding(0),
+	), tomo.R("", "Slider"), "focused"),
+	
+	// *.Slider[horizontal]
+	style.Ru(style.AS (
+		tomo.AMinimumSize(48, 0),
+	), tomo.R("", "Slider"), "horizontal"),
+	
+	// *.Slider[vertical]
+	style.Ru(style.AS (
+		tomo.AMinimumSize(0, 48),
+	), tomo.R("", "Slider"), "vertical"),
+
+	// *.SliderHandle
+	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("", "SliderHandle")),
+
+	// *.SliderHandle[horizontal]
+	style.Ru(style.AS (
+		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),
+	), tomo.R("", "ScrollContainer")),
+
+	// *.Checkbox
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 1),
+				Color: borderColorEngraved,
+			}),
+		tomo.AColor(tomo.ColorSunken),
+		tomo.APadding(0, 1, 1, 0),
+		tomo.AMinimumSize(19, 19),
+		tomo.ATexture(nil),
+		tomo.ATextureMode(tomo.TextureModeCenter),
+	), tomo.R("", "Checkbox")),
+
+	// *.Checkbox[focused]
+	style.Ru(style.AS (
+		tomo.ABorder (
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorFocused,
+			}),
+		tomo.APadding(0),
+	), tomo.R("", "Checkbox"), "focused"),
+
+	// *.Checkbox[checked]
+	style.Ru(style.AS (
+		tomo.ATexture(textureCheckboxChecked),
+	), tomo.R("", "Checkbox"), "checked"),
+
+	// *.MenuItem
+	style.Ru(style.AS (
+		tomo.AttrPadding(tomo.I(4)),
+		tomo.AttrGap { X: 4, Y: 4 },
+		tomo.AttrColor { Color: color.Transparent },
+	), tomo.R("", "MenuItem")),
+
+	// *MenuItem[focused]
+	style.Ru(style.AS (
+		tomo.AttrColor { Color: tomo.ColorAccent },
+	), tomo.R("", "MenuItem"), "focused"),
+
+	// *.File
+	style.Ru(style.AS (
+		tomo.AttrColor { Color: color.Transparent },
+	), tomo.R("", "File")),
+
+	// *.File[focused]
+	style.Ru(style.AS (
+		tomo.AttrColor { Color: tomo.ColorAccent },
+	), tomo.R("", "File"), "focused"),
+
+	// *.TearLine
+	style.Ru(style.AS (
+		tomo.ABorder (
+			tomo.Border {
+				Width: tomo.I(3),
+				Color: [4]color.Color {
+					color.Transparent,
+					color.Transparent,
+					color.Transparent,
+					color.Transparent,
+				},
+			}),
+		tomo.ATexture(textureTearLine),
+		tomo.APadding(1, 0, 0, 1),
+	), tomo.R("", "TearLine")),
+
+	// *.TearLine[focused]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(3),
+				Color: borderColorFocused,
+			},
+		},
+	), tomo.R("", "TearLine"), "focused"),
+	
+	// *.Calendar
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(0, 1, 1, 0),
+				Color: borderColorShade,
+			},
+			outline,
+		},
+		tomo.AttrColor { Color: colorInput },
+		tomo.AttrPadding(tomo.I(2)),
+		tomo.AttrGap { X: 2, Y: 2 },
+	), tomo.R("", "Calendar")),
+	
+	// *.CalendarGrid
+	style.Ru(style.AS (
+		tomo.AttrGap { X: 2, Y: 2 },
+	), tomo.R("", "CalendarGrid")),
+	
+	// *.CalendarWeekdayHeader
+	style.Ru(style.AS (
+		tomo.AttrPadding(tomo.I(2)),
+		tomo.AttrColor { Color: colorCalendarWeekdayHeader },
+	), tomo.R("", "CalendarWeekdayHeader")),
+	
+	// *.CalendarDay[weekday]
+	style.Ru(style.AS (
+		tomo.AttrPadding(tomo.I(2)),
+		tomo.AttrMinimumSize { X: 32, Y: 32 },
+		tomo.AttrColor { Color: colorCalendarDay },
+	), tomo.R("", "CalendarDay"), "weekday"),
+
+	// *.CalendarDay[weekend]
+	style.Ru(style.AS (
+		tomo.AttrPadding(tomo.I(2)),
+		tomo.AttrMinimumSize { X: 32, Y: 32 },
+		tomo.AttrColor { Color: colorCalendarWeekend },
+	), tomo.R("", "CalendarDay"), "weekend"),
+
+	// *.Notebook
+	style.Ru(style.AS (
+		tomo.AGap(0, 0),
+	), tomo.R("", "Notebook")),
+
+	// *.PageWrapper
+	style.Ru(style.AS (
+		tomo.ABorder (
+			tomo.Border {
+				Width: tomo.I(0, 1, 1, 1),
+				Color: borderColorOutline,
+			},
+			tomo.Border {
+				Width: tomo.I(0, 1, 1, 1),
+				Color: borderColorLifted,
+			}),
+		tomo.AColor(tomo.ColorBackground),
+		tomo.APadding(8),
+	), tomo.R("", "PageWrapper")),
+	
+	// *.TabRow
+	style.Ru(style.AS (
+		tomo.AGap(0, 0),
+		tomo.AttrPadding(tomo.I(1, 0, 0, 0)),
+	), tomo.R("", "TabRow")),
+	
+	// *.TabSpacer[right]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 0),
+				Color: [4]color.Color {
+					colorTransparent, colorTransparent,
+					colorTransparent, colorTransparent,
+				},
+			},
+			tomo.Border {
+				Width: tomo.I(0, 0, 1, 0),
+				Color: borderColorEngraved,
+			},
+			tomo.Border {
+				Width: tomo.I(0, 0, 1, 1),
+				Color: borderColorOutline,
+			},
+		},
+		tomo.AttrMinimumSize { X: 3 },
+	), tomo.R("", "TabSpacer"), "right"),
+	
+	// *.Tab
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 0),
+				Color: [4]color.Color {
+					colorTransparent, colorTransparent,
+					colorTransparent, colorTransparent,
+				},
+			},
+			tomo.Border {
+				Width: tomo.I(0, 0, 1, 0),
+				Color: borderColorEngraved,
+			},
+			tomo.Border {
+				Width: tomo.I(1, 0, 1, 1),
+				Color: borderColorOutline,
+			},
+			tomo.Border {
+				Width: tomo.I(1, 1, 0, 1),
+				Color: borderColorLifted,
+			},
+		},
+		tomo.AttrPadding(tomo.I(4, 8, 4, 8)),
+		tomo.AttrColor { Color: tomo.ColorRaised },
+	), tomo.R("", "Tab")),
+	
+	// *.Tab[active]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 1),
+				Color: borderColorOutline,
+			},
+			tomo.Border {
+				Width: tomo.I(1, 1, 0, 1),
+				Color: borderColorLifted,
+			},
+		},
+		tomo.AttrPadding(tomo.I(4, 8, 7, 8)),
+		tomo.AttrColor { Color: tomo.ColorBackground },
+	), tomo.R("", "Tab"), "active"),
+
+	// *.Swatch
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+		},
+		tomo.AttrMinimumSize { X: 19, Y: 19 },
+	), tomo.R("", "Swatch")),
+
+	// *.Swatch[focused]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+			tomo.Border {
+				Width: tomo.I(1),
+				Color: borderColorFocused,
+			},
+		},
+	), tomo.R("", "Swatch"), "focused"),
+
+	// *.ColorPickerMap
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			outline,
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 1),
+				Color: borderColorEngraved,
+			},
+		},
+		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 {
+		Rules: rules,
+		Colors: map[tomo.Color] color.Color {
+			tomo.ColorBackground: colorBackground,
+			tomo.ColorForeground: colorForeground,
+			tomo.ColorRaised:     colorCarved,
+			tomo.ColorSunken:     colorCarved,
+			tomo.ColorAccent:     colorFocus,
+		},
+	}, cookie
+}

internal/styles/misc/styleconcept.tss

@@ -0,0 +1,21 @@
+$colorBlack    = #000000FF;
+$borderOutline = $black 1;
+
+*.Slider {
+	Border:  $borderOutline, $borderColorFocused 1;
+	Color:   $colorGutter;
+	Padding: 0 1 1 0;
+}
+
+*.Slider[focused] {
+	Border:  $borderOutline;
+	Padding: 0;
+}
+
+*.Slider[horizontal] {
+	MinimumSize: 48 0;
+}
+
+*.Slider[vertical] {
+	MinimumSize: 0 48;
+}

internal/styles/misc/styleminimal.tss

@@ -0,0 +1,14 @@
+$ColorBackground = #FFF;
+$ColorForeground = #000;
+$ColorRaised     = #AAA;
+$ColorSunken     = #888;
+$ColorAccent     = #0FF;
+
+*.* {
+	Color:     $ColorBackground;
+	Border:    $ColorForeground / 1;
+	TextColor: $ColorForeground;
+	DotColor:  $ColorAccent;
+	Padding:   2;
+}
+

internal/styles/tss/build.go

@@ -0,0 +1,399 @@
+package tss
+
+import "os"
+import "fmt"
+import "image"
+import "errors"
+import "image/color"
+import _ "image/png"
+import "path/filepath"
+import "git.tebibyte.media/tomo/tomo"
+import "git.tebibyte.media/tomo/tomo/event"
+import "git.tebibyte.media/tomo/tomo/canvas"
+import "git.tebibyte.media/tomo/backend/style"
+
+type styleBuilder struct {
+	sheet      Sheet
+	workingDir string
+	textures   map[string] canvas.TextureCloser
+}
+
+// BuildStyle builds a Tomo style from the specified sheet. Resources associated
+// with it (such as textures) can be freed by closing the returned cookie.
+func BuildStyle (sheet Sheet) (*style.Style, event.Cookie, error) {
+	builder := &styleBuilder {
+		sheet:      sheet,
+		workingDir: filepath.Dir(sheet.Path),
+	}
+	return builder.build()
+}
+
+func (this *styleBuilder) build () (*style.Style, event.Cookie, error) {
+	// ensure the sheet is flattened (all vars are resolved)
+	err := this.sheet.Flatten()
+	if err != nil { return nil, nil, err }
+	
+	getColor := func (name string) color.Color {
+		if list, ok := this.sheet.Variables[name]; ok {
+			if len(list) > 0 {
+				if col, ok := list[0].(ValueColor); ok {
+					return col				
+				}
+			}
+		}
+		return color.RGBA { R: 255, B: 255, A: 255 }
+	}
+
+	// construct style and get colors
+	cookies := []event.Cookie { }
+	sty := &style.Style {
+		Rules: make([]style.Rule, len(this.sheet.Rules)),
+		Colors: map[tomo.Color] color.Color {
+			tomo.ColorBackground: getColor("ColorBackground"),
+			tomo.ColorForeground: getColor("ColorForeground"),
+			tomo.ColorRaised:     getColor("ColorRaised"),
+			tomo.ColorSunken:     getColor("ColorSunken"),
+			tomo.ColorAccent:     getColor("ColorAccent"),
+		},
+	}
+
+	// build style rules from the sheet's rule slice
+	for index, rule := range this.sheet.Rules {
+		styleRule := style.Rule {
+			Role: tomo.Role {
+				Package: rule.Selector.Package,
+				Object:  rule.Selector.Object,
+			},
+			Tags: rule.Selector.Tags,
+			Set:  make(style.AttrSet),
+		}
+		for name, attr := range rule.Attrs {
+			styleAttr, cookie, err := this.buildAttr(name, attr)
+			if err != nil { return nil, nil, err }
+			styleRule.Set.Add(styleAttr)
+			if cookie != nil {
+				cookies = append(cookies, cookie)
+			}
+		}
+		sty.Rules[index] = styleRule
+	}
+
+	// add each texture to the cookies list
+	for _, texture := range this.textures {
+		cookies = append(cookies, texture)
+	}
+	
+	return sty, event.MultiCookie(cookies...), nil
+}
+
+func (this *styleBuilder) buildAttr (name string, attr []ValueList) (tomo.Attr, event.Cookie, error) {
+	errWrongType := func () error {
+		return errors.New(fmt.Sprintf("wrong type for %s attribute", name))
+	}
+	expectSingle := func () error {
+		if len(attr) != 1 {
+			return errors.New(fmt.Sprintf (
+				"%s attribute requires exactly one value list",
+				name))
+		}
+		return nil
+	}
+	expectSingleSingle := func () error {
+		err := expectSingle()
+		if err != nil { return err }
+		if len(attr[0]) != 1 {
+			return errors.New(fmt.Sprintf (
+				"%s attribute requires exactly one value",
+				name))
+		}
+		return nil
+	}
+	expectNumbers := func (list ValueList) error {
+		for _, value := range list {
+			if _, ok := value.(ValueNumber); ok { continue }
+			return errWrongType()
+		}
+		return nil
+	}
+	numbers := func (list ValueList) ([]int, error) {
+		nums := make([]int, len(list))
+		for index, value := range list {
+			if value, ok := value.(ValueNumber); ok {
+				nums[index] = int(value)
+				continue
+			}
+			return nil, errWrongType()
+		}
+		return nums, nil
+	}
+	bools := func (list ValueList) ([]bool, error) {
+		bools := make([]bool, len(list))
+		for index, value := range list {
+			if value, ok := value.(ValueKeyword); ok {
+				switch value {
+				case "true":
+					bools[index] = true
+					continue
+				case "false":
+					bools[index] = false
+					continue
+				}
+			}
+			return nil, errWrongType()
+		}
+		return bools, nil
+	}
+	point := func (list ValueList) (image.Point, error) {
+		err := expectNumbers(list)
+		if err != nil { return image.Point { }, err }
+		
+		vector := image.Point { }
+		switch len(attr[0]) {
+		case 1:
+			vector.X = int(list[0].(ValueNumber))
+			vector.Y = int(list[0].(ValueNumber))
+		case 2:
+			vector.X = int(list[0].(ValueNumber))
+			vector.Y = int(list[1].(ValueNumber))
+		default:
+			return image.Point { }, errors.New(fmt.Sprintf (
+				"%s attribute requires exactly one or two values",
+				name))
+		}
+		return vector, nil
+	}
+	
+	switch name {
+	case "Color":
+		err := expectSingleSingle()
+		if err != nil { return nil, nil, err }
+		if col, ok := attr[0][0].(ValueColor); ok {
+			return tomo.AColor(col), nil, nil
+		}
+		return nil, nil, errWrongType()
+		
+	case "Texture":
+		err := expectSingleSingle()
+		if err != nil { return nil, nil, err }
+		if name, ok := attr[0][0].(ValueString); ok {
+			texture, err := this.texture(string(name))
+			if err != nil { return nil, nil, err }
+			return tomo.ATexture(texture), nil, nil
+		}
+		return nil, nil, errWrongType()
+	
+	case "TextureMode":
+		err := expectSingleSingle()
+		if err != nil { return nil, nil, err }
+		if keyword, ok := attr[0][0].(ValueKeyword); ok {
+			switch keyword {
+			case "tile":   return tomo.ATextureMode(tomo.TextureModeCenter), nil, nil
+			case "center": return tomo.ATextureMode(tomo.TextureModeCenter), nil, nil
+			}
+			return nil, nil, errors.New(fmt.Sprintf (
+				"unknown texture mode: %s",
+				keyword))
+		}
+		return nil, nil, errWrongType()
+	
+	case "Border":
+		attrBorder, err := buildAttrBorder(attr)
+		if err != nil { return nil, nil, err }
+		return attrBorder, nil, nil
+	
+	case "MinimumSize":
+		err := expectSingle()
+		if err != nil { return nil, nil, err }
+		vector, err := point(attr[0])
+		if err != nil { return nil, nil, err }
+		return tomo.AttrMinimumSize(vector), nil, nil
+	
+	case "Padding":
+		err := expectSingle()
+		if err != nil { return nil, nil, err }
+		numbers, err := numbers(attr[0])
+		if err != nil { return nil, nil, err }
+		inset := tomo.Inset { }
+		if !copyBorderValue(inset[:], numbers) {
+			return nil, nil, errors.New(fmt.Sprintf (
+				"%s attribute requires exactly one, two, or four values",
+				name))
+		}
+		return tomo.AttrPadding(inset), nil, nil
+		
+	case "Gap":
+		err := expectSingle()
+		if err != nil { return nil, nil, err }
+		vector, err := point(attr[0])
+		if err != nil { return nil, nil, err }
+		return tomo.AttrGap(vector), nil, nil
+	
+	case "TextColor":
+		err := expectSingleSingle()
+		if err != nil { return nil, nil, err }
+		if col, ok := attr[0][0].(ValueColor); ok {
+			return tomo.ATextColor(col), nil, nil
+		}
+		return nil, nil, errWrongType()
+			
+	case "DotColor":
+		err := expectSingleSingle()
+		if err != nil { return nil, nil, err }
+		if col, ok := attr[0][0].(ValueColor); ok {
+			return tomo.ADotColor(col), nil, nil
+		}
+		return nil, nil, errWrongType()
+			
+	case "Face":
+		// TODO support weight, italic, slant
+		err := expectSingle()
+		if err != nil { return nil, nil, err }
+		list := attr[0]
+		if len(list) != 2 {
+			return nil, nil, errors.New(fmt.Sprintf (
+				"%s attribute requires exactly two values",
+				name))
+		}
+		name, ok := list[0].(ValueString)
+		if !ok { return nil, nil, errWrongType() }
+		size, ok := list[1].(ValueNumber)
+		if !ok { return nil, nil, errWrongType() }
+		return tomo.AFace(tomo.Face {
+			Font: string(name),
+			Size: float64(size),
+		}), nil, nil
+		
+	case "Wrap":
+		err := expectSingleSingle()
+		if err != nil { return nil, nil, err }
+		if value, ok := attr[0][0].(ValueKeyword); ok {
+			switch value {
+			case "true":  return tomo.AWrap(true),  nil, nil
+			case "false": return tomo.AWrap(false), nil, nil
+			}
+		}
+		return nil, nil, errWrongType()
+		
+	case "Align":
+		err := expectSingle()
+		if err != nil { return nil, nil, err }
+		list := attr[0]
+		if len(list) != 2 {
+			return nil, nil, errors.New(fmt.Sprintf (
+				"%s attribute requires exactly two values",
+				name))
+		}
+		aligns := [2]tomo.Align { }
+		for index, value := range list {
+			if keyword, ok := value.(ValueKeyword); ok {
+				switch keyword {
+				case "start":  aligns[index] = tomo.AlignStart;  continue
+				case "middle": aligns[index] = tomo.AlignMiddle; continue
+				case "end":    aligns[index] = tomo.AlignEnd;    continue
+				case "even":   aligns[index] = tomo.AlignEven;   continue
+				default: return nil, nil, errors.New(fmt.Sprintf (
+					"unknown texture mode: %s",
+					keyword))					
+				}
+			}
+			return nil, nil, errWrongType()
+		}
+		return tomo.AAlign(aligns[0], aligns[1]), nil, nil
+		
+	case "Overflow":
+		err := expectSingle()
+		if err != nil { return nil, nil, err }
+		bools, err := bools(attr[0])
+		if err != nil { return nil, nil, err }
+		if len(bools) != 2 {
+			return nil, nil, errors.New(fmt.Sprintf (
+				"%s attribute requires exactly two values",
+				name))
+		}
+		return tomo.AOverflow(bools[0], bools[1]), nil, nil
+		
+	case "Layout":
+		// TODO allow use of some layouts in the objects package
+		
+	default: return nil, nil, errors.New(fmt.Sprintf("unknown attribute name %s", name))
+	}
+	return nil, nil, errors.New(fmt.Sprintf("unimplemented attribute name %s", name))
+}
+
+func (this *styleBuilder) texture (path string) (canvas.TextureCloser, error) {
+	path = filepath.Join(this.workingDir, path)
+	if texture, ok := this.textures[path]; ok {
+		return texture, nil
+	}
+	file, err := os.Open(path)
+	if err != nil { return nil, err }
+	defer file.Close()
+	rawImage, _, err := image.Decode(file)
+	if err != nil { return nil, err }
+	return tomo.NewTexture(rawImage), nil
+}
+
+func buildAttrBorder (attr []ValueList) (tomo.Attr, error) {
+	borders := make([]tomo.Border, len(attr))
+	for index, list := range attr {
+		colors := make([]color.Color, 0, len(list))
+		sizes  := make([]int, 0, len(list))
+		
+		capturingSize := false
+		for _, value := range list {
+			if capturingSize {
+				if value, ok := value.(ValueNumber); ok {
+					sizes = append(sizes, int(value))
+					continue
+				}
+			} else {
+				if _, ok := value.(ValueCut); ok {
+					capturingSize = true
+					continue
+				}
+				if value, ok := value.(ValueColor); ok {
+					colors = append(colors, value)
+					continue
+				}
+			}
+			return nil, errors.New("malformed Border attribute value list")
+		}
+		
+		border := tomo.Border { }
+		if !copyBorderValue(border.Width[:], sizes) {
+			return nil, errors.New("malformed Border attribute width list")
+		}
+		if !copyBorderValue(border.Color[:], colors) {
+			return nil, errors.New("malformed Border attribute color list")
+		}
+		borders[index] = border
+	}
+	
+	return tomo.ABorder(borders...), nil
+}
+
+func copyBorderValue[T any, U ~[]T] (destination, source U) bool {
+	if len(source) > len(destination) { return false } 
+	switch len(source) {
+	case 1:
+		destination[0] = source[0]
+		destination[1] = source[0]
+		destination[2] = source[0]
+		destination[3] = source[0]
+		return true
+	case 2:
+		destination[0] = source[0]
+		destination[1] = source[1]
+		destination[2] = source[0]
+		destination[3] = source[1]
+		return true
+	case 4:
+		destination[0] = source[0]
+		destination[1] = source[1]
+		destination[2] = source[2]
+		destination[3] = source[3]
+		return true
+	default:
+		return false
+	}
+}

internal/styles/tss/color_test.go

@@ -0,0 +1,17 @@
+package tss
+
+import "testing"
+
+func TestValueColor (test *testing.T) {
+	testValueColorRGBA(test, 0xFB380CFF, 0xFBFB, 0x3838, 0x0C0C, 0xFFFF)
+	testValueColorRGBA(test, 0xFB380C00, 0x0000, 0x0000, 0x0000, 0x0000)
+}
+
+func testValueColorRGBA (test *testing.T, col ValueColor, r, g, b, a uint32) {
+	gr, gg, gb, ga := col.RGBA()
+	test.Logf("testing RGBA for color #%08X", col)
+	if gr != r { test.Errorf("r component inequal (%04X != %04X)", gr, r) }
+	if gg != g { test.Errorf("g component inequal (%04X != %04X)", gg, g) }
+	if gb != b { test.Errorf("b component inequal (%04X != %04X)", gb, b) }
+	if ga != a { test.Errorf("a component inequal (%04X != %04X)", ga, a) }
+}

internal/styles/tss/flatten.go

@@ -0,0 +1,53 @@
+package tss
+
+import "fmt"
+import "errors"
+
+// Flatten evaluates all variables recursively, thereby eliminating all
+// instances of ValueVariable.
+func (this *Sheet) Flatten () error {
+	if this.flat { return nil }
+	this.flat = true
+	
+	for name, variable := range this.Variables {
+		variable, err := this.eval(variable)
+		if err != nil { return err }
+		this.Variables[name] = variable
+	}
+	
+	for index, rule := range this.Rules {
+		for name, attr := range rule.Attrs {
+			for index, list := range attr {
+				list, err := this.eval(list)
+				if err != nil { return err }
+				attr[index] = list
+			}
+			rule.Attrs[name] = attr
+		}
+		this.Rules[index] = rule
+	}
+	
+	return nil
+}
+
+func (this *Sheet) eval (source ValueList) (ValueList, error) {
+	destination := make(ValueList, 0, len(source))
+	for _, value := range source {
+		if name, ok := value.(ValueVariable); ok {
+			variable, ok := this.Variables[string(name)]
+			if !ok {
+				return nil, errors.New(fmt.Sprintf(
+					"variable $%s does not exist",
+					value))
+			}
+			variable, err := this.eval(variable)
+			if err != nil { return nil, err }
+			destination = append(destination, variable...)
+			continue
+		} else {
+			destination = append(destination, value)
+		}
+	}
+	
+	return destination, nil
+}

internal/styles/tss/lex.go

@@ -0,0 +1,363 @@
+package tss
+
+import "io"
+import "bufio"
+import "unicode"
+import "unicode/utf8"
+import "git.tebibyte.media/sashakoshka/goparse"
+
+const (
+	Comment parse.TokenKind = iota
+	LBrace
+	RBrace
+	LBracket
+	RBracket
+	Equals
+	Colon
+	Comma
+	Semicolon
+	Star
+	Dot
+	Dollar
+	Slash
+	Color
+	Ident
+	Number
+	String
+)
+
+var tokenNames = map[parse.TokenKind] string {
+	parse.EOF: "EOF",
+	Comment: "Comment",
+	LBrace: "LBrace",
+	RBrace: "RBrace",
+	LBracket: "LBracket",
+	RBracket: "RBracket",
+	Equals: "Equals",
+	Colon: "Colon",
+	Comma: "Comma",
+	Semicolon: "Semicolon",
+	Star: "Star",
+	Dot: "Dot",
+	Dollar: "Dollar",
+	Slash: "Slash",
+	Color: "Color",
+	Ident: "Ident",
+	Number: "Number",
+	String: "String",
+}
+
+type lexer struct {
+	filename    string
+	lineScanner *bufio.Scanner
+	rune        rune
+	line        string
+	lineFood    string
+
+	offset   int
+	row      int
+	column   int
+
+	eof bool
+}
+
+func Lex (filename string, reader io.Reader) parse.Lexer {
+	lex := &lexer {
+		filename:    filename,
+		lineScanner: bufio.NewScanner(reader),
+	}
+	lex.nextRune()
+	return lex
+}
+
+func (this *lexer) Next () (parse.Token, error) {
+	for {
+		token, err := this.next()
+		if err == io.EOF { return token, this.errUnexpectedEOF() }
+		if err != nil    { return token, err                     }
+
+		if !token.Is(Comment) {
+			return token, err
+		}
+	}
+}
+
+func (this *lexer) next () (token parse.Token, err error) {
+	err = this.skipWhitespace()
+	token.Position = this.pos()
+	if this.eof {
+		token.Kind = parse.EOF
+		err = nil
+		return
+	}
+	if err != nil { return }
+
+	appendRune := func () {
+		token.Value += string(this.rune)
+		err = this.nextRune()
+	}
+
+	skipRune := func () {
+		err = this.nextRune()
+	}
+
+	defer func () {
+		newPos := this.pos()
+		newPos.End --
+		token.Position = token.Position.Union(newPos)
+	} ()
+
+	switch {
+	case this.rune == '/':
+		token.Kind = Comment
+		skipRune()
+		if err != nil { return }
+		if this.rune == '/' {
+			for this.rune != '\n' {
+				skipRune()
+				if err != nil { return }
+			}
+		} else {
+			token.Kind = Slash
+		}
+		if this.eof { err = nil; return }
+
+	case this.rune == '{':
+		token.Kind = LBrace
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == '}':
+		token.Kind = RBrace
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == '[':
+		token.Kind = LBracket
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == ']':
+		token.Kind = RBracket
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == '=':
+		token.Kind = Equals
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == ':':
+		token.Kind = Colon
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == ',':
+		token.Kind = Comma
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == ';':
+		token.Kind = Semicolon
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == '*':
+		token.Kind = Star
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == '.':
+		token.Kind = Dot
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == '$':
+		token.Kind = Dollar
+		appendRune()
+		if this.eof { err = nil; return }
+
+	case this.rune == '#':
+		token.Kind = Color
+		skipRune()
+		if err != nil { return }
+		for isHexDigit(this.rune) {
+			appendRune()
+			if this.eof { err = nil; return }
+		}
+		if this.eof { err = nil; return }
+
+	case unicode.IsLetter(this.rune):
+		token.Kind = Ident
+		for unicode.IsLetter(this.rune) || unicode.IsNumber(this.rune) {
+			appendRune()
+			if this.eof { err = nil; return }
+		}
+		if this.eof { err = nil; return }
+
+	case this.rune == '-':
+		token.Kind = Number
+		appendRune()
+		for isDigit(this.rune) {
+			appendRune()
+			if this.eof { err = nil; return }
+		}
+		if this.eof { err = nil; return }
+		
+	case isDigit(this.rune):
+		token.Kind = Number
+		for isDigit(this.rune) {
+			appendRune()
+			if this.eof { err = nil; return }
+		}
+		if this.eof { err = nil; return }
+		
+	case this.rune == '\'', this.rune == '"':
+		stringDelimiter := this.rune
+		token.Kind = String
+		err = this.nextRune()
+		if err != nil { return }
+
+		for this.rune != stringDelimiter {
+			if this.rune == '\\' {
+				var result rune
+				result, err = this.escapeSequence(stringDelimiter)
+				if err != nil { return }
+				token.Value += string(result)
+			} else {
+				appendRune()
+				if this.eof { err = nil; return }
+				if err != nil { return }
+			}
+		}
+		err = this.nextRune()
+		if this.eof { err = nil; return }
+		if err != nil { return }
+
+	default:
+		err = parse.Errorf (
+			this.pos(), "unexpected rune %U",
+			this.rune)
+	}
+
+	return
+}
+
+func (this *lexer) nextRune () error {
+	if this.lineFood == "" {
+		ok := this.lineScanner.Scan()
+		if ok {
+			this.line     = this.lineScanner.Text()
+			this.lineFood = this.line
+			this.rune     = '\n'
+			this.column   = 0
+			this.row      ++
+		} else {
+			err := this.lineScanner.Err()
+			if err == nil {
+				this.eof = true
+				return io.EOF
+			} else {
+				return err
+			}
+		}
+	} else {
+		var ch   rune
+		var size int
+		for ch == 0 && this.lineFood != "" {
+			ch, size = utf8.DecodeRuneInString(this.lineFood)
+			this.lineFood = this.lineFood[size:]
+		}
+		this.rune = ch
+		this.column ++
+	}
+
+	return nil
+}
+
+func (this *lexer) escapeSequence (stringDelimiter rune) (rune, error) {
+	err := this.nextRune()
+	if err != nil { return 0, err }
+
+	if isDigit(this.rune) {
+		var number rune
+		for index := 0; index < 3; index ++ {
+			if !isDigit(this.rune) { break }
+		
+			number *= 8
+			number += this.rune - '0'
+
+			err = this.nextRune()
+			if err != nil { return 0, err }
+		}
+		return number, nil
+	}
+
+	defer this.nextRune()
+	switch this.rune {
+	case '\\', '\n', stringDelimiter:
+		return this.rune, nil
+	case 'a': return '\a', nil
+	case 'b': return '\b', nil
+	case 't': return '\t', nil
+	case 'n': return '\n', nil
+	case 'v': return '\v', nil
+	case 'f': return '\f', nil
+	case 'r': return '\r', nil
+	default: return 0, this.errBadEscapeSequence()
+	}
+}
+
+func (this *lexer) skipWhitespace () error {
+	for isWhitespace(this.rune) {
+		err := this.nextRune()
+		if err != nil { return err }
+	}
+	return nil
+}
+
+func (this *lexer) pos () parse.Position {
+	return parse.Position {
+		File:   this.filename,
+		Line:   this.lineScanner.Text(),
+		Row:    this.row    - 1,
+		Start:  this.column - 1,
+		End:    this.column,
+	}
+}
+
+func (this *lexer) errUnexpectedEOF () error {
+	return parse.Errorf(this.pos(), "unexpected EOF")
+}
+
+func (this *lexer) errBadEscapeSequence () error {
+	return parse.Errorf(this.pos(), "bad escape sequence")
+}
+
+func isWhitespace (char rune) bool {
+	switch char {
+	case ' ', '\t', '\r', '\n': return true
+	default: return false
+	}
+}
+
+func isSymbol (char rune) bool {
+	switch char {
+	case
+		'~', '!', '@', '#', '$', '%', '^', '&', '-', '_', '=', '+',
+		'\\', '|', ';', ',', '<', '>', '/', '?':
+		return true
+	default:
+		return false
+	}
+}
+
+func isDigit (char rune) bool {
+	return char >= '0' && char <= '9'
+}
+
+func isHexDigit (char rune) bool {
+	return isDigit(char) ||
+		char >= 'a' && char <= 'f' ||
+		char >= 'A' && char <= 'F'
+}

internal/styles/tss/lex_test.go

@@ -0,0 +1,66 @@
+package tss
+
+import "fmt"
+import "strings"
+import "testing"
+import "git.tebibyte.media/sashakoshka/goparse"
+
+func TestLexSimple (test *testing.T) {
+testString(test,
+`hello #BABE {#Beef}, 384920 #0ab3fc840`,
+tok(Ident, "hello"),
+tok(Color, "BABE"),
+tok(LBrace, "{"),
+tok(Color, "Beef"),
+tok(RBrace, "}"),
+tok(Comma, ","),
+tok(Number, "384920"),
+tok(Color, "0ab3fc840"),
+tok(parse.EOF, ""),
+)}
+
+func testString (test *testing.T, input string, correct ...parse.Token) {
+	lexer := Lex("test.tss", strings.NewReader(input))
+	index := 0
+	for {
+		token, err := lexer.Next()
+		if err != nil { test.Fatalf("lexer returned error:\n%v", parse.Format(err)) }
+		if index >= len(correct) {
+			test.Logf("%d:\t%-16s | !", index, tokStr(token))
+			test.Fatalf("index %d greater than %d", index, len(correct))
+		}
+		correctToken := correct[index]
+		test.Logf (
+			"%d:\t%-16s | %s",
+			index,
+			tokStr(token),
+			tokStr(correctToken))
+		if correctToken.Kind != token.Kind || correctToken.Value != token.Value {
+			test.Fatalf("tokens at %d do not match up", index)
+		}
+		if token.Is(parse.EOF) { break }
+		index ++
+	}
+	if index < len(correct) - 1 {
+		test.Fatalf("index %d less than %d", index, len(correct) - 1)
+	}
+}
+
+func tokStr (token parse.Token) string {
+	name, ok := tokenNames[token.Kind]
+	if !ok {
+		name = fmt.Sprintf("Token(%d)", token.Kind)
+	}
+	if token.Value == "" {
+		return name
+	} else {
+		return fmt.Sprintf("%s:\"%s\"", name, token.Value)
+	}
+}
+
+func tok (kind parse.TokenKind, value string) parse.Token {
+	return parse.Token {
+		Kind:  kind,
+		Value: value,
+	}
+}

internal/styles/tss/parse.go

@@ -0,0 +1,254 @@
+package tss
+
+import "io"
+import "strconv"
+import "git.tebibyte.media/sashakoshka/goparse"
+
+type parser struct {
+	parse.Parser
+	sheet Sheet
+	lexer parse.Lexer
+}
+
+func newParser (lexer parse.Lexer) *parser {
+	return &parser {
+		sheet: Sheet {
+			Variables: make(map[string] ValueList),
+		},
+		Parser: parse.Parser {
+			Lexer:      lexer,
+			TokenNames: tokenNames,
+		},
+	}
+}
+
+func Parse (lexer parse.Lexer) (Sheet, error) {
+	parser := newParser(lexer)
+	err := parser.parse()
+	if err == io.EOF { err = nil }
+	if err != nil { return Sheet { }, err }
+	return parser.sheet, nil
+}
+
+func (this *parser) parse () error {
+	err := this.Next()
+	if err != nil { return err }
+	for this.Token.Kind != parse.EOF {
+		err = this.parseTopLevel()
+		if err != nil { return err }
+	}
+	return nil
+}
+
+func (this *parser) parseTopLevel () error {
+	err := this.ExpectDesc("variable or rule", Dollar, Ident, Star)
+	if err != nil { return err }
+	if this.EOF() { return nil }
+	pos := this.Pos()
+	
+	switch this.Kind() {
+	case Dollar:
+		name, variable, err := this.parseVariable()
+		if err != nil { return err }
+		if _, exists := this.sheet.Variables[name]; exists {
+			return parse.Errorf(pos, "variable %s already declared", name)
+		}
+		this.sheet.Variables[name] = variable
+		
+	case Ident, Star:
+		rule, err := this.parseRule()
+		if err != nil { return err }
+		this.sheet.Rules = append(this.sheet.Rules, rule)
+	}
+	return nil
+}
+
+func (this *parser) parseVariable () (string, ValueList, error) {
+	err := this.Expect(Dollar)
+	if err != nil { return "", nil, err }
+	err = this.ExpectNext(Ident)
+	if err != nil { return "", nil, err }
+	name := this.Value()
+	err = this.ExpectNext(Equals)
+	if err != nil { return "", nil, err }
+	this.Next()
+	values, err := this.parseValueList()
+	if err != nil { return "", nil, err }
+	err = this.Expect(Semicolon)
+	if err != nil { return "", nil, err }
+	return name, values, this.Next()
+}
+
+func (this *parser) parseRule () (Rule, error) {
+	rule := Rule {
+		Attrs: make(map[string] []ValueList),
+	}
+	
+	selector, err := this.parseSelector()
+	if err != nil { return Rule { }, err }
+	rule.Selector = selector
+	err = this.Expect(LBrace)
+	if err != nil { return Rule { }, err }
+	
+	for {
+		this.Next()
+		if this.Is(RBrace) { break }
+		pos := this.Pos()
+		name, attr, err := this.parseAttr()
+		if err != nil { return Rule { }, err }
+		err = this.Expect(Semicolon)
+		if err != nil { return Rule { }, err }
+		if _, exists := rule.Attrs[name]; exists {
+			return Rule { }, parse.Errorf (
+				pos,
+				"attribute %s already declared in this rule",
+				name)
+		}
+		rule.Attrs[name] = attr
+	}
+	
+	return rule, this.Next()
+}
+
+func (this *parser) parseSelector () (Selector, error) {
+	selector := Selector { }
+
+	// package
+	err := this.ExpectDesc("selector", Ident, Star)
+	if err != nil { return Selector { }, err }
+	if this.Is(Ident) {
+		selector.Package = this.Value()
+	}
+	
+	err = this.ExpectNext(Dot)
+	if err != nil { return Selector { }, err }
+
+	// object
+	err = this.ExpectNext(Ident, Star)
+	if err != nil { return Selector { }, err }
+	if this.Is(Ident) {
+		selector.Object = this.Value()
+	}
+
+	// tags
+	err = this.ExpectNext(LBracket)
+	if err == nil {
+		for {
+			this.Next()
+			err := this.Expect(Ident, String, RBracket)
+			if err != nil { return Selector { }, err }
+			if this.Is(RBracket) { break       }
+			if this.Is(Comma)    { this.Next() }
+			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()
+	}
+	
+	return selector, nil
+}
+
+func (this *parser) parseAttr () (string, []ValueList, error) {
+	err := this.ExpectDesc("attr", Ident)
+	if err != nil { return "", nil, err }
+	name := this.Value()
+
+	err = this.ExpectNext(Colon)
+	if err != nil { return "", nil, err }
+
+	attr := []ValueList { }
+	this.Next()
+	for {
+		err := this.ExpectDesc (
+			"value, Comma, or Semicolon",
+			Number, Color, String, Ident, Dollar, Slash,
+			Comma, Semicolon)
+		if err != nil { return "", nil, err }
+		if this.Is(Semicolon) { break       }
+		if this.Is(Comma)     { this.Next() }
+		valueList, err := this.parseValueList()
+		if err != nil { return "", nil, err }
+		attr = append(attr, valueList)
+		err = this.Expect(Comma, Semicolon)
+		if err != nil { return "", nil, err }
+	}
+	
+	return name, attr, nil
+}
+
+func (this *parser) parseValueList () (ValueList, error) {
+	list := ValueList { }
+	for {
+		err := this.ExpectDesc (
+			"value",
+			Number, Color, String, Ident, Dollar, Slash)
+		if err != nil { break }
+		switch this.Kind() {
+		case Number:
+			number, err := strconv.Atoi(this.Value())
+			if err != nil { return nil, err }
+			list = append(list, ValueNumber(number))
+		case Color:
+			color, ok := parseColor([]rune(this.Value()))
+			if !ok {
+				return nil, parse.Errorf (
+					this.Pos(),
+					"malformed color literal")
+			}
+			list = append(list, ValueColor(color))
+		case String:
+			list = append(list, ValueString(this.Value()))
+		case Ident:
+			list = append(list, ValueKeyword(this.Value()))
+		case Dollar:
+			err := this.ExpectNext(Ident)
+			if err != nil { return nil, err }
+			list = append(list, ValueVariable(this.Value()))
+		case Slash:
+			list = append(list, ValueCut { })
+		}
+		this.Next()
+	}
+	return list, nil
+}
+
+func parseColor (runes []rune) (uint32, bool) {
+	digits := make([]uint32, len(runes))
+	for index, run := range runes {
+		digit := hexDigit(run)
+		if digit < 0 { return 0, false }
+		digits[index] = uint32(digit)
+	}
+	switch len(runes) {
+	case 3:
+		return  digits[0] << 28 | digits[0] << 24 |
+			digits[1] << 20 | digits[1] << 16 |
+			digits[2] << 12 | digits[2] <<  8 | 0xFF, true
+	case 6:
+		return  digits[0] << 28 | digits[1] << 24 |
+			digits[2] << 20 | digits[3] << 16 |
+			digits[4] << 12 | digits[5] <<  8 | 0xFF, true
+	case 4:
+		return  digits[0] << 28 | digits[0] << 24 |
+			digits[1] << 20 | digits[1] << 16 |
+			digits[2] << 12 | digits[2] <<  8 |
+			digits[3] <<  4 | digits[3] <<  0, true
+	case 8:
+		return  digits[0] << 28 | digits[1] << 24 |
+			digits[2] << 20 | digits[3] << 16 |
+			digits[4] << 12 | digits[5] <<  8 |
+			digits[6] <<  4 | digits[7] <<  0, true
+	default: return 0, false
+	}
+}
+
+func hexDigit (digit rune) int {
+	switch {
+	case digit >= '0' && digit <= '9': return int(digit - '0')
+	case digit >= 'a' && digit <= 'f': return int(digit - 'a') + 10
+	case digit >= 'A' && digit <= 'F': return int(digit - 'A') + 10
+	default: return -1
+	}
+}

internal/styles/tss/tss.go

@@ -0,0 +1,81 @@
+package tss
+
+import "os"
+import "git.tebibyte.media/tomo/tomo/event"
+import "git.tebibyte.media/tomo/backend/style"
+
+type Sheet struct {
+	Path      string
+	Variables map[string] ValueList
+	Rules     []Rule
+	flat      bool
+}
+
+type Rule struct {
+	Selector Selector
+	Attrs    map[string] []ValueList
+}
+
+type Selector struct {
+	Package string
+	Object  string
+	Tags    []string
+}
+
+type ValueList []Value
+
+type Value interface {
+	value ()
+}
+
+type ValueNumber int
+func (ValueNumber) value () { }
+
+type ValueColor uint32
+func (ValueColor) value () { }
+func (value ValueColor) RGBA () (r, g, b, a uint32) {
+	// extract components
+	bits := uint32(value)
+	r = (bits & 0xFF000000) >> 24
+	g = (bits & 0x00FF0000) >> 16
+	b = (bits & 0x0000FF00) >> 8
+	a = (bits & 0x000000FF)
+	// extend to 16 bits per channel
+	r = r << 8 | r
+	g = g << 8 | g
+	b = b << 8 | b
+	a = a << 8 | a
+	// alpha premultiply
+	r = (r * a) / 0xFFFF
+	g = (g * a) / 0xFFFF
+	b = (b * a) / 0xFFFF
+	return
+}
+
+type ValueString string
+func (ValueString) value () { }
+
+type ValueKeyword string
+func (ValueKeyword) value () { }
+
+type ValueVariable string
+func (ValueVariable) value () { }
+
+type ValueCut struct { }
+func (ValueCut) value () { }
+
+// LoadFile loads the stylesheet from the specified file. This may return a
+// parse.Error, so use parse.Format to print it.
+func LoadFile (name string) (*style.Style, event.Cookie, error) {
+	// TODO check cache for gobbed sheet. if the cache is nonexistent or
+	// invalid, then open/load/cache.
+	
+	file, err := os.Open(name)
+	if err != nil { return nil, nil, err }
+	defer file.Close()
+
+	sheet, err := Parse(Lex(name, file))
+	if err != nil { return nil, nil, err }
+	sheet.Path = name
+	return BuildStyle(sheet)
+}

internal/styles/tss/tss.yaml

@@ -0,0 +1,35 @@
+# Happen to use Micro to edit text?
+# Drop this in ~/.config/micro/syntax and get syntax highlighting for TSS files!
+
+filetype: tss
+
+detect:
+        filename: "\\.tss$"
+
+rules:
+        - type: "\\b([A-Z][a-zA-Z0-9]*).*:"
+        - identifier.var: "\\$[a-zA-Z0-9]*\\b"
+        - identifier.class: "(\\*|[a-z][a-zA-Z0-9]*)\\.(\\*|[A-Z][a-zA-Z0-9]*)"
+        - constant: "\\b(tile|center)\\b"
+        - constant: "\\b(start|middle|end|even)\\b"
+        - constant.bool: "\\b(true|false)\\b"
+        - special: "(\\/|,|\\;|:|\\.)"
+        - symbol.operator: "(=|\\*)"
+        - symbol.brackets: "(\\{\\[|\\}\\])"
+
+        - comment:
+                start: "//"
+                end: "$"
+                rules:
+                        - todo: "(TODO|XXX|FIXME|BUG):?"
+        
+        - constant.string:
+                start: "\""
+                end: "\""
+                skip: "\\\\."
+                rules:
+                        - constant.specialChar: "\\\\[abfnrtv'\\\"\\\\]"
+                        - constant.specialChar: "\\\\([0-7]{3})"
+
+        - constant.number: "\\b[0-9][0-9.]*\\b"
+        - constant.string: "\\B#[0-9a-fA-F]*"

internal/theme/attribute.go

@@ -1,41 +0,0 @@
-package theme
-
-import "image"
-import "image/color"
-import "golang.org/x/image/font"
-import "git.tebibyte.media/tomo/tomo"
-
-// Attr modifies one thing about an Objects's style.
-type Attr interface { attr () int }
-
-// AttrColor sets the background color of an Objects.
-type AttrColor struct { color.Color }
-// AttrTexture sets the texture of an Objects to a named texture.
-type AttrTexture string
-// AttrBorder sets the border of an Objects.
-type AttrBorder []tomo.Border
-// AttrMinimumSize sets the minimum size of an Objects.
-type AttrMinimumSize image.Point
-// AttrPadding sets the inner padding of an Objects.
-type AttrPadding tomo.Inset
-// AttrGap sets the gap between child Objects, if the Object is a ContainerBox.
-type AttrGap image.Point
-// AttrTextColor sets the text color, if the Object is a TextBox.
-type AttrTextColor struct { color.Color }
-// AttrDotColor sets the text selection color, if the Object is a TextBox.
-type AttrDotColor struct { color.Color }
-// AttrFace sets the font face, if the Object is a TextBox.
-type AttrFace struct { font.Face }
-// AttrAlign sets the alignment, if the Object is a ContentBox.
-type AttrAlign struct { X, Y tomo.Align }
-
-func (AttrColor)       attr () int { return 0 }
-func (AttrTexture)     attr () int { return 1 }
-func (AttrBorder)      attr () int { return 2 }
-func (AttrMinimumSize) attr () int { return 3 }
-func (AttrPadding)     attr () int { return 4 }
-func (AttrGap)         attr () int { return 5 }
-func (AttrTextColor)   attr () int { return 6 }
-func (AttrDotColor)    attr () int { return 7 }
-func (AttrFace)        attr () int { return 8 }
-func (AttrAlign)       attr () int { return 9 }

internal/theme/missing.go

@@ -1,24 +0,0 @@
-package theme
-
-import "image"
-import "image/color"
-
-type missingTexture int
-
-func (texture missingTexture) ColorModel () color.Model {
-	return color.RGBAModel
-}
-
-func (texture missingTexture) Bounds () image.Rectangle {
-	return image.Rect(0, 0, int(texture), int(texture))
-}
-
-func (texture missingTexture) At (x, y int) color.Color {
-	x /= 8
-	y /= 8
-	if (x + y) % 2 == 0 {
-		return color.RGBA { R: 0xFF, B: 0xFF, A: 0xFF }
-	} else {
-		return color.RGBA { A: 0xFF }
-	}
-}

internal/theme/style/aluminum/default.go

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

internal/theme/style/aluminum/style.go

@@ -1,305 +0,0 @@
-package aluminumStyle
-
-import "image/color"
-import "git.tebibyte.media/tomo/tomo"
-import "golang.org/x/image/font/basicfont"
-import dataTheme "git.tebibyte.media/tomo/nasin/internal/theme"
-
-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(0xd6d6d6FF)
-var colorForeground    = color.Black
-var colorOutline       = color.Black
-var colorGutter        = hex(0xbfc6d1FF)
-var colorGutterHovered = hex(0xc5cbd6FF)
-var colorCarved        = hex(0xe9eaeaFF)
-var colorCarvedPressed = hex(0xe3e4e4FF)
-var colorCarvedFocused = hex(0xe4e6e8FF)
-var colorCarvedHovered = hex(0xf1f3f5FF)
-
-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 borderFocused     = border(0x5f8bc4FF, 0x5f8bc4FF, 0x5f8bc4ff, 0x5f8bc4ff, 1)
-var borderInnerShadow = border(0xa4afc0FF, 0xa4afc0FF, 0xa4afc0ff, 0xa4afc0ff, 1, 0, 0, 1)
-var borderOuterShadow = border(0xa4afc0FF, 0xa4afc0FF, 0xa4afc0ff, 0xa4afc0ff, 0, 1, 1, 0)
-
-var rules = []dataTheme.Rule {
-	// *.*[*]
-	dataTheme.Rule {
-		Default: dataTheme.AS (
-			dataTheme.AttrFace      { Face:  basicfont.Face7x13    },
-			dataTheme.AttrTextColor { Color: tomo.ColorForeground  },
-			dataTheme.AttrDotColor  { Color: colorDot              },
-			dataTheme.AttrGap       { X: 8, Y: 8                   },
-		),
-	},
-
-	// *.Button[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Button", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderLifted,
-			},
-			dataTheme.AttrPadding(tomo.I(4, 8)),
-			dataTheme.AttrColor { Color: tomo.ColorRaised },
-		),
-		Pressed: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			dataTheme.AttrPadding(tomo.I(5, 8, 4, 9)),
-			dataTheme.AttrColor { Color: colorCarvedPressed },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderFocused,
-				borderLifted,
-			},
-			dataTheme.AttrPadding(tomo.I(4, 8)),
-			dataTheme.AttrColor { Color: colorCarvedFocused },
-		),
-		Hovered: dataTheme.AS (
-			dataTheme.AttrColor { Color: colorCarvedHovered },
-		),
-	},
-
-	// *.TextInput[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "TextInput", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			dataTheme.AttrColor { Color: tomo.ColorSunken },
-			dataTheme.AttrPadding(tomo.I(5, 4, 4, 5)),
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderFocused,
-				borderInnerShadow,
-			},
-		),
-	},
-
-	// *.TextView[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "TextView", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			dataTheme.AttrColor { Color: tomo.ColorSunken },
-			dataTheme.AttrPadding(tomo.I(8)),
-		),
-	},
-	
-	// *.NumberInput[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "NumberInput", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrGap { },
-		),
-	},
-
-	// *.Container[sunken]
-	dataTheme.Rule {
-		Role: tomo.R("", "Container", "sunken"),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			dataTheme.AttrColor { Color: tomo.ColorSunken },
-			dataTheme.AttrPadding(tomo.I(8)),
-		),
-	},
-
-	// *.Container[outer]
-	dataTheme.Rule {
-		Role: tomo.R("", "Container", "outer"),
-		Default: dataTheme.AS (
-			dataTheme.AttrColor { Color: tomo.ColorBackground },
-			dataTheme.AttrPadding(tomo.I(8)),
-		),
-	},
-
-	// *.Container[menu]
-	dataTheme.Rule {
-		Role: tomo.R("", "Container", "menu"),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderGap,
-				borderLifted,
-			},
-			dataTheme.AttrColor { Color: tomo.ColorBackground },
-			dataTheme.AttrGap { },
-		),
-	},
-
-	// *.Heading[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Heading", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrAlign { X: tomo.AlignMiddle, Y: tomo.AlignMiddle },
-		),
-	},
-
-	// *.Separator[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Separator", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-			},
-		),
-	},
-
-	// *.Slider[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Slider", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			dataTheme.AttrColor { Color: colorGutter },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderFocused,
-				borderInnerShadow,
-			},
-		),
-		Hovered: dataTheme.AS (
-			dataTheme.AttrColor { Color: colorGutterHovered },
-		),
-	},
-	
-	// *.Slider[horizontal]
-	dataTheme.Rule {
-		Role: tomo.R("", "Slider", "horizontal"),
-		Default: dataTheme.AS(dataTheme.AttrMinimumSize { X: 48 }),
-	},
-	
-	// *.Slider[vertical]
-	dataTheme.Rule {
-		Role: tomo.R("", "Slider", "vertical"),
-		Default: dataTheme.AS(dataTheme.AttrMinimumSize { Y: 48 }),
-	},
-
-	// *.SliderHandle[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "SliderHandle", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderOuterShadow,
-				borderGap,
-				borderLifted,
-			},
-			dataTheme.AttrColor { Color: tomo.ColorRaised },
-			dataTheme.AttrMinimumSize { X: 12, Y: 12, },
-		),
-	},
-
-	// *.Checkbox[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Checkbox", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderGap,
-				borderInnerShadow,
-			},
-			dataTheme.AttrColor { Color: tomo.ColorSunken },
-			dataTheme.AttrPadding(tomo.I(0, 1, 1, 0)),
-			dataTheme.AttrMinimumSize { X: 19, Y: 19 },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrBorder {
-				borderEngraved,
-				borderFocused,
-				borderInnerShadow,
-			},
-			dataTheme.AttrPadding(tomo.I(0)),
-		),
-	},
-
-	// *.LabelCheckbox[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "LabelCheckbox", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrGap { X: 8, Y: 8 },
-		),
-	},
-
-	// *.MenuItem[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "MenuItem", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrPadding(tomo.I(4)),
-			dataTheme.AttrGap { X: 4, Y: 4 },
-			dataTheme.AttrColor { Color: color.Transparent },
-		),
-		Hovered: dataTheme.AS (
-			dataTheme.AttrColor { Color: colorDot },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrColor { Color: colorDot },
-		),
-	},
-
-	// *.File[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "File", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrColor { Color: color.Transparent },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrColor { Color: colorDot },
-		),
-	},
-}

internal/theme/style/fallback/style.go

@@ -1,309 +0,0 @@
-package fallbackStyle
-
-import "image/color"
-import "git.tebibyte.media/tomo/tomo"
-import "golang.org/x/image/font/basicfont"
-import dataTheme "git.tebibyte.media/tomo/nasin/internal/theme"
-
-var colorFocus         = color.RGBA { R:  61, G: 128, B: 143, A: 255 }
-var colorInput         = color.RGBA { R: 208, G: 203, B: 150, A: 255 }
-var colorCarved        = color.RGBA { R: 151, G: 160, B: 150, A: 255 }
-var colorGutter        = color.RGBA { R: 116, G: 132, B: 126, A: 255 }
-var colorShadow        = color.RGBA { R:  57, G:  59, B:  57, A: 255 }
-var colorInputShadow   = color.RGBA { R: 143, G: 146, B:  91, A: 255 }
-var colorHighlight     = color.RGBA { R: 207, G: 215, B: 210, A: 255 }
-var colorBackground    = color.RGBA { R: 169, G: 171, B: 168, A: 255 }
-var colorCarvedPressed = color.RGBA { R: 129, G: 142, B: 137, A: 255 }
-var colorForeground    = color.Black
-var colorOutline       = color.Black
-
-var outline = tomo.Border {
-	Width: tomo.I(1),
-	Color: [4]color.Color {
-		colorOutline,
-		colorOutline,
-		colorOutline,
-		colorOutline,
-	},
-}
-
-var borderColorEngraved = [4]color.Color { colorShadow,      colorHighlight, colorHighlight, colorShadow }
-var borderColorLifted   = [4]color.Color { colorHighlight,   colorShadow,    colorShadow,    colorHighlight }
-var borderColorInput    = [4]color.Color { colorInputShadow, colorInput,     colorInput,     colorInputShadow }
-var borderColorFocused  = [4]color.Color { colorFocus,       colorFocus,     colorFocus,     colorFocus }
-
-var rules = []dataTheme.Rule {
-	// *.*[*]
-	dataTheme.Rule {
-		Default: dataTheme.AS (
-			dataTheme.AttrFace      { Face:  basicfont.Face7x13    },
-			dataTheme.AttrTextColor { Color: tomo.ColorForeground  },
-			dataTheme.AttrDotColor  { Color: tomo.ColorAccent      },
-			dataTheme.AttrGap       { X: 8, Y: 8                   },
-		),
-	},
-
-	// *.Button[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Button", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorLifted,
-				},
-			},
-			dataTheme.AttrPadding(tomo.I(4, 8)),
-			dataTheme.AttrColor { Color: tomo.ColorRaised },
-		),
-		Pressed: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1, 0, 0, 1),
-					Color: borderColorEngraved,
-				},
-			},
-			dataTheme.AttrPadding(tomo.I(5, 8, 4, 9)),
-			dataTheme.AttrColor { Color: colorCarvedPressed },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorFocused,
-				},
-			},
-			dataTheme.AttrPadding(tomo.I(4, 8)),
-		),
-	},
-
-	// *.TextInput[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "TextInput", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorInput,
-				},
-			},
-			dataTheme.AttrColor { Color: colorInput },
-			dataTheme.AttrPadding(tomo.I(5, 4, 4, 5)),
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorFocused,
-				},
-			},
-		),
-	},
-
-	// *.TextView[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "TextView", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1, 0, 0, 1),
-					Color: borderColorEngraved,
-				},
-			},
-			dataTheme.AttrColor { Color: tomo.ColorSunken },
-			dataTheme.AttrPadding(tomo.I(8)),
-		),
-	},
-	
-	// *.NumberInput[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "NumberInput", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrGap { },
-		),
-	},
-
-	// *.Container[sunken]
-	dataTheme.Rule {
-		Role: tomo.R("", "Container", "sunken"),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1, 0, 0, 1),
-					Color: borderColorEngraved,
-				},
-			},
-			dataTheme.AttrColor { Color: tomo.ColorSunken },
-			dataTheme.AttrPadding(tomo.I(8)),
-		),
-	},
-
-	// *.Container[outer]
-	dataTheme.Rule {
-		Role: tomo.R("", "Container", "outer"),
-		Default: dataTheme.AS (
-			dataTheme.AttrColor { Color: tomo.ColorBackground },
-			dataTheme.AttrPadding(tomo.I(8)),
-		),
-	},
-
-	// *.Container[menu]
-	dataTheme.Rule {
-		Role: tomo.R("", "Container", "menu"),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorLifted,
-				},
-			},
-			dataTheme.AttrColor { Color: tomo.ColorBackground },
-			dataTheme.AttrGap { },
-		),
-	},
-
-	// *.Heading[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Heading", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrAlign { X: tomo.AlignMiddle, Y: tomo.AlignMiddle },
-		),
-	},
-
-	// *.Separator[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Separator", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorEngraved,
-				},
-			},
-		),
-	},
-
-	// *.Slider[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Slider", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1, 0, 0, 1),
-					Color: borderColorEngraved,
-				},
-			},
-			dataTheme.AttrColor { Color: colorGutter },
-			dataTheme.AttrPadding(tomo.I(0, 1, 1, 0)),
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorFocused,
-				},
-			},
-			dataTheme.AttrPadding(tomo.I(0)),
-		),
-	},
-	
-	// *.Slider[horizontal]
-	dataTheme.Rule {
-		Role: tomo.R("", "Slider", "horizontal"),
-		Default: dataTheme.AS(dataTheme.AttrMinimumSize { X: 48 }),
-	},
-	
-	// *.Slider[vertical]
-	dataTheme.Rule {
-		Role: tomo.R("", "Slider", "vertical"),
-		Default: dataTheme.AS(dataTheme.AttrMinimumSize { Y: 48 }),
-	},
-
-	// *.SliderHandle[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "SliderHandle", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorLifted,
-				},
-			},
-			dataTheme.AttrColor { Color: tomo.ColorRaised },
-			dataTheme.AttrMinimumSize { X: 12, Y: 12, },
-		),
-	},
-
-	// *.Checkbox[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "Checkbox", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1, 0, 0, 1),
-					Color: borderColorEngraved,
-				},
-			},
-			dataTheme.AttrColor { Color: tomo.ColorSunken },
-			dataTheme.AttrPadding(tomo.I(0, 1, 1, 0)),
-			dataTheme.AttrMinimumSize { X: 19, Y: 19 },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrBorder {
-				outline,
-				tomo.Border {
-					Width: tomo.I(1),
-					Color: borderColorFocused,
-				},
-			},
-			dataTheme.AttrPadding(tomo.I(0)),
-		),
-	},
-
-	// *.LabelCheckbox[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "LabelCheckbox", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrGap { X: 8, Y: 8 },
-		),
-	},
-
-	// *.MenuItem[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "MenuItem", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrPadding(tomo.I(4)),
-			dataTheme.AttrGap { X: 4, Y: 4 },
-			dataTheme.AttrColor { Color: color.Transparent },
-		),
-		Hovered: dataTheme.AS (
-			dataTheme.AttrColor { Color: tomo.ColorAccent },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrColor { Color: tomo.ColorAccent },
-		),
-	},
-
-	// *.File[*]
-	dataTheme.Rule {
-		Role: tomo.R("", "File", ""),
-		Default: dataTheme.AS (
-			dataTheme.AttrColor { Color: color.Transparent },
-		),
-		Focused: dataTheme.AS (
-			dataTheme.AttrColor { Color: tomo.ColorAccent },
-		),
-	},
-}

internal/theme/style/fallback/wintergreen.go

@@ -1,20 +0,0 @@
-package fallbackStyle
-
-import "image/color"
-import "git.tebibyte.media/tomo/tomo"
-import dataTheme "git.tebibyte.media/tomo/nasin/internal/theme"
-
-// New returns Wintergreen, the default Tomo tomo. It is neutral-gray with green
-// and turquoise accents.
-func New () *dataTheme.Theme {
-	return &dataTheme.Theme {
-		Colors: map[tomo.Color] color.Color {
-			tomo.ColorBackground: colorBackground,
-			tomo.ColorForeground: colorForeground,
-			tomo.ColorRaised:     colorCarved,
-			tomo.ColorSunken:     colorCarved,
-			tomo.ColorAccent:     colorFocus,
-		},
-		Rules: rules,
-	}
-}

internal/theme/theme.go

@@ -1,268 +0,0 @@
-// Package theme provides a data-driven theme implementation.
-package theme
-
-import "image"
-import "image/color"
-import "git.tebibyte.media/tomo/tomo"
-import "git.tebibyte.media/tomo/tomo/data"
-import "git.tebibyte.media/tomo/tomo/event"
-import "git.tebibyte.media/tomo/tomo/input"
-import "git.tebibyte.media/tomo/tomo/canvas"
-
-// this is CSS's bastard child
-
-// Theme allows the use of data to define a visual style.
-type Theme struct {
-	// Textures maps texture names to image textures.
-	Textures map[string] image.Image
-	textures map[string] canvas.TextureCloser // private texture cache
-	missing  canvas.TextureCloser             // cache for "missing" texture
-	
-	// Rules determines which styles get applied to which Objects.
-	Rules []Rule
-
-	// Colors maps tomo.Color values to color.RGBA values.
-	Colors map[tomo.Color] color.Color
-
-	// This type does not handle icons, and as such, a special icon theme
-	// must be separately specified.
-	IconTheme
-}
-
-// IconTheme implements the part of tomo.Theme that handles icons.
-type IconTheme interface {
-	// Icon returns a texture of the corresponding icon ID.
-	Icon (tomo.Icon, tomo.IconSize) canvas.Texture
-	// MimeIcon returns an icon corresponding to a MIME type.
-	MimeIcon (data.Mime, tomo.IconSize) canvas.Texture
-}
-
-// Rule describes under what circumstances should certain style attributes be
-// active.
-type Rule struct {
-	Role tomo.Role
-	Default AttrSet
-	Hovered AttrSet
-	Pressed AttrSet
-	Focused AttrSet
-}
-
-// AttrSet is a set of attributes wherein only one/zero of each attribute type
-// can exist. I deserve to be imprisoned for the way I made this work (look in
-// attribute.go). Its zero value can be used safely, and you can copy it if you
-// want, but it will point to the same set of attributes.
-type AttrSet struct {
-	set map[int] Attr
-}
-
-// AS builds an AttrSet out of a vararg list of Attr values.
-func AS (attrs ...Attr) AttrSet {
-	set := AttrSet { }
-	set.Add(attrs...)
-	return set
-}
-
-// Add adds attributes to the set.
-func (this *AttrSet) Add (attrs ...Attr) {
-	this.ensure()
-	for _, attr := range attrs {
-		this.set[attr.attr()] = attr
-	}
-}
-
-// MergeUnder takes attributes from another set and adds them if they don't
-// already exist in this one.
-func (this *AttrSet) MergeUnder (other AttrSet) {
-	this.ensure()
-	if other.set == nil { return }
-	for _, attr := range other.set {
-		if _, exists := this.set[attr.attr()]; !exists {
-			this.Add(attr)
-		}
-	}
-}
-
-// MergeOver takes attributes from another set and adds them, overriding this
-// one.
-func (this *AttrSet) MergeOver (other AttrSet) {
-	this.ensure()
-	if other.set == nil { return }
-	for _, attr := range other.set {
-		this.Add(attr)
-	}
-}
-
-func (this *AttrSet) ensure () {
-	if this.set == nil { this.set = make(map[int] Attr) }
-}
-
-func (this *Theme) execute (object tomo.Object, set AttrSet) {
-	box := object.GetBox()
-	
-	for _, attr := range set.set {
-		switch attr := attr.(type) {
-		case AttrColor:
-			box.SetColor(attr.Color)
-		case AttrTexture:
-			box.SetTextureTile(this.texture(string(attr)))
-		case AttrBorder:
-			box.SetBorder([]tomo.Border(attr)...)
-		case AttrMinimumSize:
-			box.SetMinimumSize(image.Point(attr))
-		case AttrPadding:
-			box.SetPadding(tomo.Inset(attr))
-		case AttrGap:
-			if box, ok := box.(tomo.ContainerBox); ok {
-				box.SetGap(image.Point(attr))
-			}
-		case AttrTextColor:
-			if box, ok := box.(tomo.TextBox); ok {
-				box.SetTextColor(attr.Color)
-			}
-		case AttrDotColor:
-			if box, ok := box.(tomo.TextBox); ok {
-				box.SetDotColor(attr.Color)
-			}
-		case AttrFace:
-			if box, ok := box.(tomo.TextBox); ok {
-				box.SetFace(attr)
-			}
-		case AttrAlign:
-			if box, ok := box.(tomo.ContentBox); ok {
-				box.SetAlign(attr.X, attr.Y)
-			}
-		default:
-			panic("bug: nasin/internal/tomo.Theme: unexpected attribute")
-		}
-	}
-}
-
-func (this *Theme) texture (name string) canvas.Texture {
-	this.ensureTextureCache()
-	if texture, ok := this.textures[name]; ok {
-		return texture
-	}
-	if this.Textures == nil {
-		if source, ok := this.Textures[name]; ok {
-			texture := tomo.NewTexture(source)
-			this.textures[name] = texture
-			return texture
-		}
-	}
-	return this.missingTexture()
-}
-
-func (this *Theme) missingTexture () canvas.Texture {
-	if this.missing == nil {
-		this.missing = tomo.NewTexture(missingTexture(16))
-	}
-	return this.missing
-}
-
-func (this *Theme) ensureTextureCache () {
-	if this.textures == nil { this.textures = make(map[string] canvas.TextureCloser) }
-}
-
-// setsFor builds flattened attr sets for a specific role based on the rules list
-func (this *Theme) setsFor (role tomo.Role) (defaul, hovered, pressed, focused AttrSet) {
-	for _, current := range this.Rules {
-		// check for a match
-		packageMatch := current.Role.Package == role.Package || current.Role.Package == ""
-		objectMatch  := current.Role.Object  == role.Object  || current.Role.Object  == ""
-		variantMatch := current.Role.Variant == role.Variant || current.Role.Variant == ""
-		if packageMatch && objectMatch && variantMatch {
-			// if found, merge and override
-			defaul.MergeOver(current.Default)
-			hovered.MergeOver(current.Hovered)
-			pressed.MergeOver(current.Pressed)
-			focused.MergeOver(current.Focused)
-		}
-	}
-
-	// hovered and pressed are mutually exclusive states, so we compress
-	// them with the default state.
-	hovered.MergeUnder(defaul)
-	pressed.MergeUnder(defaul)
-	return defaul, hovered, pressed, focused
-}
-
-func (this *Theme) Apply (object tomo.Object) event.Cookie {
-	pressed := false
-	hovered := false
-	box  := object.GetBox()
-	role := box.Role()
-
-	defaultSet, hoveredSet, pressedSet, focusedSet := this.setsFor(role)
-
-	updateStyle := func () {
-		if pressed {
-			this.execute(object, pressedSet)
-		} else if hovered {
-			this.execute(object, hoveredSet)
-		} else {
-			this.execute(object, defaultSet)
-		}
-		if box.Focused() && !pressed {
-			this.execute(object, focusedSet)
-		}
-	}
-	updateStyle()
-	
-	return event.MultiCookie (
-		box.OnFocusEnter(updateStyle),
-		box.OnFocusLeave(updateStyle),
-		box.OnMouseDown(func (button input.Button) {
-			if button != input.ButtonLeft { return }
-			pressed = true
-			updateStyle()
-		}),
-		box.OnMouseUp(func (button input.Button) {
-			if button != input.ButtonLeft { return }
-			pressed = false
-			updateStyle()
-		}),
-		box.OnMouseEnter(func () {
-			hovered = true
-			updateStyle()
-		}),
-		box.OnMouseLeave(func () {
-			hovered = false
-			updateStyle()
-		}))
-
-}
-
-func (this *Theme) RGBA (c tomo.Color) (r, g, b, a uint32) {
-	if this.Colors == nil { return 0xFFFF, 0, 0xFFFF, 0xFFFF }
-	color, ok := this.Colors[c]
-	if !ok { return 0xFFFF, 0, 0xFFFF, 0xFFFF }
-	return color.RGBA()
-}
-
-func (this *Theme) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
-	if this.IconTheme == nil {
-		return this.missingTexture()
-	} else {
-		return this.IconTheme.Icon(icon, size)
-	}
-}
-
-func (this *Theme) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
-	if this.IconTheme == nil {
-		return this.missingTexture()
-	} else {
-		return this.IconTheme.MimeIcon(mime, size)
-	}
-}
-
-// Close closes all cached textures this theme has open. Do not call this while
-// the theme is in use.
-func (this *Theme) Close () error {
-	this.missing.Close()
-	this.missing = nil
-	for _, texture := range this.textures {
-		texture.Close()
-	}
-	this.textures = nil
-	return nil
-}

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
+}
+
+// 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()
+		}
+	}
+
+	handleWaitClose := func () error {
+		handleClose();
+		return nil
+	}
+
+	return event.MultiCookie (
+		window.OnClose(handleClose),
+		event.FuncCookie(handleWaitClose))
+}

path.go

@@ -1,190 +1,58 @@
 package nasin
 
-import "io"
 import "os"
-import "io/fs"
-import "strings"
 import "path/filepath"
 
-// FS is Tomo's implementation of fs.FS. It provides access to a specific part
+// ApplicationUserDataDir returns the directory path where an application can
-// of the filesystem.
+// store its user data files. If the directory does not exist, it will be
-type FS struct {
+// created.
-	path string
+func ApplicationUserDataDir (app ApplicationDescription) (string, error) {
+	return userMkdirAll(app.ID, userDataDir)
 }
 
-// FileWriter is a writable version of fs.File.
+// ApplicationSystemDataDirs returns a list of directory paths where an
-type FileWriter interface {
+// application can look for its system-level data files. Directories returned
-	fs.File
+// by this function may or may not actually exist. This function may return an
-	io.Writer
+// empty slice on some platforms.
+func ApplicationSystemDataDirs (app ApplicationDescription) ([]string, error) {
+	return systemDirs(app.ID, systemDataDirs)
 }
 
-// ApplicationUserDataFS returns an FS that an application can use to store user
+// ApplicationUserConfigDir returns the directory path where an application can
-// data files.
+// store its user configuration files.
-func ApplicationUserDataFS (app ApplicationDescription) (*FS, error) {
+func ApplicationUserConfigDir (app ApplicationDescription) (string, error) {
-	dataDir, err := userDataDir()
+	return userMkdirAll(app.ID, userConfigDir)
+}
+
+// ApplicationSystemDataDirs returns a list of directory paths where an
+// application can look for its system-level configuration files. Directories
+// returned by this function may or may not actually 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) {
+	return userMkdirAll(app.ID, userCacheDir)
+}
+
+func userMkdirAll (sub string, getter func () (string, error)) (string, error) {
+	path, err := getter()
+	if err != nil { return "", err }
+	path = filepath.Join(path, sub)
+	err = os.MkdirAll(path, 0700)
+	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 }
-	return appFs(dataDir, app)
+	specificPaths := make([]string, len(paths))
-}
+	for index, path := range paths {
-
+		specificPaths[index] = filepath.Join(path, sub)
-// ApplicationUserConfigFS returns an FS that an application can use to store
-// user configuration files.
-func ApplicationUserConfigFS (app ApplicationDescription) (*FS, error) {
-	configDir, err := userConfigDir()
-	if err != nil { return nil, err }
-	return appFs(configDir, app)
-}
-
-// ApplicationUserCacheFS returns an FS that an application can use to store
-// user cache files.
-func ApplicationUserCacheFS (app ApplicationDescription) (*FS, error) {
-	cacheDir, err := userCacheDir()
-	if err != nil { return nil, err }
-	return appFs(cacheDir, app)
-}
-
-func pathErr (op, path string, err error) error {
-	return &fs.PathError {
-		Op:   op,
-		Path: path,
-		Err:  err,
 	}
-}
+	return specificPaths, nil
-
-func appFs (root string, app ApplicationDescription) (*FS, error) {
-	// remove slashes
-	appid := app.ID
-	appid = strings.ReplaceAll(appid, "/", "-")
-	appid = strings.ReplaceAll(appid, "\\", "-")
-
-	path := filepath.Join(root, appid)
-
-	// ensure the directory actually exists
-	err := os.MkdirAll(path, 700)
-	if err != nil { return nil, err }
-
-	return &FS { path: path }, nil
-}
-
-func (this FS) subPath (name string) (string, error) {
-	if !fs.ValidPath(name)         { return "", fs.ErrInvalid }
-	if strings.Contains(name, "/") { return "", fs.ErrInvalid }
-	return filepath.Join(this.path, name), nil
-}
-
-// Open opens the named file.
-func (this FS) Open (name string) (fs.File, error) {
-	path, err := this.subPath(name)
-	if err != nil {
-		return nil, pathErr("open", name, err)
-	}
-
-	return os.Open(path)
-}
-
-// Create creates or truncates the named file.
-func (this FS) Create (name string) (FileWriter, error) {
-	path, err := this.subPath(name)
-	if err != nil {
-		return nil, pathErr("create", name, err)
-	}
-
-	return os.Create(path)
-}
-
-// OpenFile is the generalized open call; most users will use Open or Create
-// instead.
-func (this FS) OpenFile (
-	name string,
-	flag int,
-	perm os.FileMode,
-) (
-	FileWriter,
-	error,
-) {
-	path, err := this.subPath(name)
-	if err != nil {
-		return nil, pathErr("open", name, err)
-	}
-
-	return os.OpenFile(path, flag, perm)
-}
-
-// ReadDir reads the named directory and returns a list of directory entries
-// sorted by filename.
-func (this FS) ReadDir (name string) ([]fs.DirEntry, error) {
-	path, err := this.subPath(name)
-	if err != nil {
-		return nil, pathErr("readdir", name, err)
-	}
-
-	return os.ReadDir(path)
-}
-
-// ReadFile reads the named file and returns its contents.
-// A successful call returns a nil error, not io.EOF.
-// (Because ReadFile reads the whole file, the expected EOF
-// from the final Read is not treated as an error to be reported.)
-//
-// The caller is permitted to modify the returned byte slice.
-func (this FS) ReadFile (name string) ([]byte, error) {
-	path, err := this.subPath(name)
-	if err != nil {
-		return nil, pathErr("readfile", name, err)
-	}
-
-	return os.ReadFile(path)
-}
-
-// WriteFile writes data to the named file, creating it if necessary.
-func (this FS) WriteFile (name string, data []byte, perm os.FileMode) error {
-	path, err := this.subPath(name)
-	if err != nil {
-		return pathErr("writefile", name, err)
-	}
-
-	return os.WriteFile(path, data, perm)
-}
-
-// Stat returns a FileInfo describing the file.
-func (this FS) Stat (name string) (fs.FileInfo, error) {
-	path, err := this.subPath(name)
-	if err != nil {
-		return nil, pathErr("stat", name, err)
-	}
-
-	return os.Stat(path)
-}
-
-// Remove removes the named file or (empty) directory.
-func (this FS) Remove (name string) error {
-	path, err := this.subPath(name)
-	if err != nil {
-		return pathErr("remove", name, err)
-	}
-
-	return os.Remove(path)
-}
-
-// RemoveAll removes name and any children it contains.
-func (this FS) RemoveAll (name string) error {
-	path, err := this.subPath(name)
-	if err != nil {
-		return pathErr("removeall", name, err)
-	}
-
-	return os.RemoveAll(path)
-}
-
-// Rename renames (moves) oldname to newname.
-func (this FS) Rename (oldname, newname string) error {
-	oldpath, err := this.subPath(oldname)
-	if err != nil {
-		return pathErr("rename", oldname, err)
-	}
-	newpath, err := this.subPath(newname)
-	if err != nil {
-		return pathErr("rename", newname, err)
-	}
-
-	return os.Rename(oldpath, newpath)
 }

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()
 }