Aluminum has complete styling for tabs

Archival dirs are pointless, we have git for a reason

README.md

@@ -2,5 +2,12 @@
 
 [![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. Parts of Tomo that
+Nasin provides an easy way to write applications with Tomo. To get started, take
-aren't the GUI toolkit may be found here.
+a look at the [examples](examples) directory and the
+[online documentation](https://pkg.go.dev/git.tebibyte.media/tomo/nasin).
+
+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

application.go

@@ -1,17 +1,55 @@
 package nasin
 
+import "fmt"
 import "log"
+import "flag"
 import "image"
+import "strings"
+import "net/url"
 import "git.tebibyte.media/tomo/tomo"
-import "git.tebibyte.media/tomo/nasin/internal/registry"
+import "git.tebibyte.media/tomo/objects"
+import "git.tebibyte.media/tomo/nasin/internal/registrar"
 
 // Application represents an application object.
 type Application interface {
 	// Describe returns a description of the application.
 	Describe () ApplicationDescription
 
-	// Init performs the initial setup of the application.
+	// Init performs the initial setup of the application. This behavior
-	Init () error
+	// should return a window if it creates one.
+	Init () (tomo.Window, error)
+}
+
+// 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.
+	//
+	// This behavior should return a window if it creates one.
+	OpenURL (*url.URL) (tomo.Window, error)
+
+	// OpenNone is called when the application is launched without any URLs
+	// to open. The application may create some sort of default starting
+	// window, or do nothing. This behavior should return a window if it
+	// creates one.
+	OpenNone () (tomo.Window, 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 +69,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 +123,152 @@ 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 := registry.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()
-	if err != nil { log.Fatal("nasin: could not run application:", err) }
+
+	reg := new(registrar.Registrar)
+	backend, err := reg.SetBackend()
+	if err != nil { log.Fatalln("nasin: could not register backend:", err) }
+	err = reg.SetTheme()
+	if err != nil { log.Fatalln("nasin: could not set theme:", err) }
+	err = reg.SetIconSet()
+	if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
+	err = reg.SetFaceSet()
+	if err != nil { log.Fatalln("nasin: could not set face set:", err) }
+	window, err := application.Init()
+	if err != nil { log.Fatalln("nasin: could not run application:", err) }
+	manageWindow(window)
+
+	// open URLs
+	args := flag.Args()
+	applicationOpenUrls(application, args...)
+
+	if windows > 0 {
+		err = backend.Run()
+		if err != nil { log.Fatalln("nasin: could not run application:", err) }
+	}
 }
 
 // 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
+// found, the default icon for the application's ApplicationRole will used.
+func NewApplicationWindow (application Application, bounds image.Rectangle) (tomo.Window, error) {
 	window, err := tomo.NewWindow(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
 }
+
+var windows int
+
+func manageWindow (window tomo.Window) {
+	if window == nil { return }
+	windows ++
+	window.OnClose(func () {
+		windows --
+		if windows < 1 {
+			tomo.Stop()
+		}
+	})
+}
+
+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)
+		manageWindow(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 {
+		window, err := application.OpenNone()
+		if err != nil {
+			log.Fatalf("nasin: could not open main window: %v", err)
+			return false
+		}
+		manageWindow(window)
+		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"
+		}
+		window, err := application.OpenURL(ur)
+		if err != nil {
+			errorPopupf(
+				"Could Not Open URL",
+				"Could not open %v: %v",
+				arg, err,
+			)(func () {
+				if !openedAny {
+					openNone()
+				}
+			})
+		}
+		manageWindow(window)
+	}
+}
+
+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
+	}
+}

go.mod

@@ -1,19 +1,21 @@
 module git.tebibyte.media/tomo/nasin
 
-go 1.20
+go 1.22.2
 
 require (
-	git.tebibyte.media/tomo/tomo v0.30.0
+	git.tebibyte.media/sashakoshka/goparse v0.2.0
-	git.tebibyte.media/tomo/x v0.6.0
+	git.tebibyte.media/tomo/backend v0.7.0
+	git.tebibyte.media/tomo/objects v0.22.0
+	git.tebibyte.media/tomo/tomo v0.46.1
 	git.tebibyte.media/tomo/xdg v0.1.0
+	golang.org/x/image v0.11.0
 )
 
 require (
-	git.tebibyte.media/tomo/typeset v0.7.0 // indirect
+	git.tebibyte.media/tomo/typeset v0.7.1 // 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.0 // indirect
+	github.com/jezek/xgb v1.1.1 // indirect
-	github.com/jezek/xgbutil v0.0.0-20230603163917-04188eb39cf0 // indirect
+	github.com/jezek/xgbutil v0.0.0-20231116234834-47f30c120111 // indirect
-	golang.org/x/image v0.11.0 // indirect
 )

go.sum

@@ -1,10 +1,14 @@
+git.tebibyte.media/sashakoshka/goparse v0.2.0 h1:uQmKvOCV2AOlCHEDjg9uclZCXQZzq2PxaXfZ1aIMiQI=
+git.tebibyte.media/sashakoshka/goparse v0.2.0/go.mod h1:tSQwfuD+EujRoKr6Y1oaRy74ZynatzkRLxjE3sbpCmk=
 git.tebibyte.media/sashakoshka/xgbkb v1.0.0/go.mod h1:pNcE6TRO93vHd6q42SdwLSTTj25L0Yzggz7yLe0JV6Q=
-git.tebibyte.media/tomo/tomo v0.30.0 h1:JoTklJ7yFVrzre4AwuKBMwzho9GomC9ySw354wDB4f4=
+git.tebibyte.media/tomo/backend v0.7.0 h1:12A+IsbwIKCmg4jKjD9xCDz+o7R3X6Yp8cZup+wOGIM=
-git.tebibyte.media/tomo/tomo v0.30.0/go.mod h1:C9EzepS9wjkTJjnZaPBh22YvVPyA4hbBAJVU20Rdmps=
+git.tebibyte.media/tomo/backend v0.7.0/go.mod h1:G3Kh6N2MuiAwsnuPe3h9CwWL65vmmsaqgapA38MPyhk=
-git.tebibyte.media/tomo/typeset v0.7.0 h1:JFpEuGmN6R2XSCvkINYxpH0AyYUqqs+dZYr6OSd91y0=
+git.tebibyte.media/tomo/objects v0.22.0 h1:2t21W32HW2xvPBICqmArVMVWxg9ohhTJw6ChZ0DcdYY=
-git.tebibyte.media/tomo/typeset v0.7.0/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
+git.tebibyte.media/tomo/objects v0.22.0/go.mod h1:f5J5tAhO+eN5glVbCJLPSopIeTylXqLgKLVAIg8iAPQ=
-git.tebibyte.media/tomo/x v0.6.0 h1:80BRiSwhZCqu6IPKZoQj7t1puKXXJpMB9eWVHQliTHM=
+git.tebibyte.media/tomo/tomo v0.46.1 h1:/8fT6I9l4TK529zokrThbNDHGRvUsNgif1Zs++0PBSQ=
-git.tebibyte.media/tomo/x v0.6.0/go.mod h1:6INfDGlcPyoYVMem64ScD5AZb43PkXDGkfgaNa5GCqQ=
+git.tebibyte.media/tomo/tomo v0.46.1/go.mod h1:WrtilgKB1y8O2Yu7X4mYcRiqOlPR8NuUnoA/ynkQWrs=
+git.tebibyte.media/tomo/typeset v0.7.1 h1:aZrsHwCG5ZB4f5CruRFsxLv5ezJUCFUFsQJJso2sXQ8=
+git.tebibyte.media/tomo/typeset v0.7.1/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
 git.tebibyte.media/tomo/xdg v0.1.0 h1:6G2WYPPiM2IXleCpKKHuJA34BxumwNWuLsUoX3yu5zA=
 git.tebibyte.media/tomo/xdg v0.1.0/go.mod h1:tuaRwRkyYW7mqlxA7P2+V+e10KzcamNoUzcOgaIYKAY=
 git.tebibyte.media/tomo/xgbkb v1.0.1 h1:b3HDUopjdQp1MZrb5Vpil4bOtk3NnNXtfQW27Blw2kE=
@@ -13,10 +17,12 @@ 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/jezek/xgb v1.1.0 h1:wnpxJzP1+rkbGclEkmwpVFQWpuE2PUGNUzP8SbfFobk=
 github.com/jezek/xgb v1.1.0/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
-github.com/jezek/xgbutil v0.0.0-20230603163917-04188eb39cf0 h1:Pf/0BAbppEOq4azPH6fnvUX2dycAwZdGkdxFn25j44c=
+github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
+github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
 github.com/jezek/xgbutil v0.0.0-20230603163917-04188eb39cf0/go.mod h1:AHecLyFNy6AN9f/+0AH/h1MI7X1+JL5bmCz4XlVZk7Y=
+github.com/jezek/xgbutil v0.0.0-20231116234834-47f30c120111 h1:cX/mTy4LgFtWqr5dCadtdJ4zdh/KtPco5yFLsliaFyU=
+github.com/jezek/xgbutil v0.0.0-20231116234834-47f30c120111/go.mod h1:AHecLyFNy6AN9f/+0AH/h1MI7X1+JL5bmCz4XlVZk7Y=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=

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/icon.go

@@ -0,0 +1,458 @@
+package fallbackIcons
+
+import "bytes"
+import "image"
+import _ "embed"
+import _ "image/png"
+import "git.tebibyte.media/tomo/tomo"
+import "git.tebibyte.media/tomo/tomo/data"
+import "git.tebibyte.media/tomo/tomo/canvas"
+import "git.tebibyte.media/tomo/backend/style"
+
+//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 {
+	atlasImage, _, err := image.Decode(bytes.NewReader(data))
+	if err != nil { panic(err) }
+	atlasTexture := tomo.NewTexture(atlasImage)
+
+	source := make(map[tomo.Icon] canvas.Texture)
+	x := 0
+	y := 0
+	
+	row := func () {
+		x = 0
+		y ++
+	}
+	col := func (id tomo.Icon) {
+		source[id] = atlasTexture.SubTexture(image.Rect (
+			x * width,
+			y * width,
+			(x + 1) * width,
+			(y + 1) * width))
+		x++
+	}
+
+	col(tomo.IconUnknown)
+	col(tomo.Icon("File"))
+
+	row()
+	// actions
+	col(tomo.IconAddressBookNew)
+	col(tomo.IconApplicationExit)
+	col(tomo.IconAppointmentNew)
+	col(tomo.IconCallStart)
+	col(tomo.IconCallStop)
+	col(tomo.IconContactNew)
+	// actions: dialog
+	col(tomo.IconDialogOkay)
+	col(tomo.IconDialogCancel)
+	// actions: edit
+	col(tomo.IconEditClear)
+	col(tomo.IconEditCopy)
+	col(tomo.IconEditCut)
+	col(tomo.IconEditDelete)
+	col(tomo.IconEditFind)
+	col(tomo.IconEditFindReplace)
+	col(tomo.IconEditPaste)
+	col(tomo.IconEditRedo)
+	col(tomo.IconEditSelectAll)
+	col(tomo.IconEditUndo)
+	// actions: file
+	col(tomo.IconFileNew)
+	col(tomo.IconDirectoryNew)
+	col(tomo.IconFileOpen)
+	col(tomo.IconFileOpenRecent)
+	col(tomo.IconFilePageSetup)
+	col(tomo.IconFilePrint)
+	col(tomo.IconFilePrintPreview)
+	col(tomo.IconFilePermissions)
+	col(tomo.IconFileProperties)
+	col(tomo.IconFileRename)
+	col(tomo.IconFileRevert)
+	col(tomo.IconFileSave)
+	col(tomo.IconFileSaveAs)
+	col(tomo.IconFileSend)
+
+	row()
+	// actions: format
+	col(tomo.IconFormatIndentLess)
+	col(tomo.IconFormatIndentMore)
+	col(tomo.IconFormatAlignCenter)
+	col(tomo.IconFormatAlignEven)
+	col(tomo.IconFormatAlignLeft)
+	col(tomo.IconFormatAlignRight)
+	col(tomo.IconFormatTextDirectionLtr)
+	col(tomo.IconFormatTextDirectionRtl)
+	col(tomo.IconFormatTextBold)
+	col(tomo.IconFormatTextItalic)
+	col(tomo.IconFormatTextUnderline)
+	col(tomo.IconFormatTextStrikethrough)
+	// actions: go
+	col(tomo.IconGoBottom)
+	col(tomo.IconGoDown)
+	col(tomo.IconGoFirst)
+	col(tomo.IconGoHome)
+	col(tomo.IconGoJump)
+	col(tomo.IconGoLast)
+	col(tomo.IconGoNext)
+	col(tomo.IconGoPrevious)
+	col(tomo.IconGoTop)
+	col(tomo.IconGoUp)
+	// actions: help
+	col(tomo.IconHelpAbout)
+	col(tomo.IconHelpContents)
+	col(tomo.IconHelpFaq)
+	// actions: insert
+	col(tomo.IconInsertImage)
+	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
+	col(tomo.IconMailForward)
+	col(tomo.IconMailMarkImportant)
+	col(tomo.IconMailMarkJunk)
+	col(tomo.IconMailMarkNotJunk)
+	col(tomo.IconMailMarkRead)
+	col(tomo.IconMailMarkUnread)
+	col(tomo.IconMailMessageNew)
+	col(tomo.IconMailReplyAll)
+	col(tomo.IconMailReplySender)
+	col(tomo.IconMailSend)
+	col(tomo.IconMailReceive)
+	// actions: media
+	col(tomo.IconMediaEject)
+	col(tomo.IconMediaPlaybackPause)
+	col(tomo.IconMediaPlaybackStart)
+	col(tomo.IconMediaPlaybackStop)
+	col(tomo.IconMediaRecord)
+	col(tomo.IconMediaSeekBackward)
+	col(tomo.IconMediaSeekForward)
+	col(tomo.IconMediaSkipBackward)
+	col(tomo.IconMediaSkipForward)
+	// actions: object
+	col(tomo.IconObjectFlipHorizontal)
+	col(tomo.IconObjectFlipVertical)
+	col(tomo.IconObjectRotateLeft)
+	col(tomo.IconObjectRotateRight)
+	// actions: process
+	col(tomo.IconProcessStop)
+	// actions: system
+	col(tomo.IconSystemLockScreen)
+	col(tomo.IconSystemLogOut)
+	col(tomo.IconSystemRun)
+	col(tomo.IconSystemSearch)
+	col(tomo.IconSystemReboot)
+	col(tomo.IconSystemShutdown)
+
+	row()
+	// actions: tools
+	col(tomo.IconToolsCheckSpelling)
+	// actions: value
+	col(tomo.IconValueIncrement)
+	col(tomo.IconValueDecrement)
+	col(tomo.IconValueReset)
+	// actions: view
+	col(tomo.IconViewFullscreen)
+	col(tomo.IconViewRefresh)
+	col(tomo.IconViewRestore)
+	col(tomo.IconViewSortAscending)
+	col(tomo.IconViewSortDescending)
+	// actions: window
+	col(tomo.IconWindowClose)
+	col(tomo.IconWindowNew)
+	// actions: zoom
+	col(tomo.IconZoomFitBest)
+	col(tomo.IconZoomIn)
+	col(tomo.IconZoomOriginal)
+	col(tomo.IconZoomOut)
+
+	row()
+	// applications
+	// Keep these in sync with nasin.ApplicationRole!
+	col(tomo.IconApplication)
+	col(tomo.IconApplicationWebBrowser)
+	col(tomo.IconApplicationMesssanger)
+	col(tomo.IconApplicationPhone)
+	col(tomo.IconApplicationMail)
+	col(tomo.IconApplicationTerminalEmulator)
+	col(tomo.IconApplicationFileBrowser)
+	col(tomo.IconApplicationTextEditor)
+	col(tomo.IconApplicationDocumentViewer)
+	col(tomo.IconApplicationWordProcessor)
+	col(tomo.IconApplicationSpreadsheet)
+	col(tomo.IconApplicationSlideshow)
+	col(tomo.IconApplicationCalculator)
+	col(tomo.IconApplicationPreferences)
+	col(tomo.IconApplicationProcessManager)
+	col(tomo.IconApplicationSystemInformation)
+	col(tomo.IconApplicationManual)
+	col(tomo.IconApplicationCamera)
+	col(tomo.IconApplicationImageViewer)
+	col(tomo.IconApplicationMediaPlayer)
+	col(tomo.IconApplicationImageEditor)
+	col(tomo.IconApplicationAudioEditor)
+	col(tomo.IconApplicationVideoEditor)
+	col(tomo.IconApplicationClock)
+	col(tomo.IconApplicationCalendar)
+	col(tomo.IconApplicationChecklist)
+
+	row()
+	// categories: applications
+	col(tomo.IconApplications)
+	col(tomo.IconApplicationsAccessories)
+	col(tomo.IconApplicationsDevelopment)
+	col(tomo.IconApplicationsEngineering)
+	col(tomo.IconApplicationsGames)
+	col(tomo.IconApplicationsGraphics)
+	col(tomo.IconApplicationsInternet)
+	col(tomo.IconApplicationsMultimedia)
+	col(tomo.IconApplicationsOffice)
+	col(tomo.IconApplicationsScience)
+	col(tomo.IconApplicationsSystem)
+	col(tomo.IconApplicationsUtilities)
+	// categories: preferences
+	col(tomo.IconPreferences)
+	col(tomo.IconPreferencesDesktop)
+	col(tomo.IconPreferencesPeripherals)
+	col(tomo.IconPreferencesPersonal)
+	col(tomo.IconPreferencesSystem)
+	col(tomo.IconPreferencesNetwork)
+
+	row()
+	// devices
+	col(tomo.IconDevice)
+	col(tomo.IconDeviceCamera)
+	col(tomo.IconDeviceWebCamera)
+	col(tomo.IconDeviceComputer)
+	col(tomo.IconDevicePda)
+	col(tomo.IconDevicePhone)
+	col(tomo.IconDevicePrinter)
+	col(tomo.IconDeviceScanner)
+	col(tomo.IconDeviceMultimediaPlayer)
+	col(tomo.IconDeviceVideoDisplay)
+	col(tomo.IconDeviceAudioInput)
+	col(tomo.IconDeviceAudioOutput)
+	// devices: hardware
+	col(tomo.IconHardware)
+	col(tomo.IconHardwareCPU)
+	col(tomo.IconHardwareGPU)
+	col(tomo.IconHardwareRAM)
+	col(tomo.IconHardwareSoundCard)
+	col(tomo.IconHardwareNetworkAdapter)
+	// devices: power
+	col(tomo.IconPowerBattery)
+	// devices: storage
+	col(tomo.IconStorageHardDisk)
+	col(tomo.IconStorageFloppyDisk)
+	col(tomo.IconStorageSolidState)
+	col(tomo.IconStorageOptical)
+	col(tomo.IconStorageFlashStick)
+	col(tomo.IconStorageFlashCard)
+	col(tomo.IconStorageMagneticTape)
+	// devices: input
+	col(tomo.IconInputGaming)
+	col(tomo.IconInputKeyboard)
+	col(tomo.IconInputMouse)
+	col(tomo.IconInputTablet)
+
+	row()
+	// devices: network
+	col(tomo.IconNetworkWired)
+	col(tomo.IconNetworkWireless)
+	col(tomo.IconNetworkCellular)
+	col(tomo.IconNetworkLocal)
+	col(tomo.IconNetworkInternet)
+	col(tomo.IconNetworkVPN)
+	col(tomo.IconNetworkServer)
+	col(tomo.IconNetworkWorkgroup)
+
+	row()
+	// emblems
+	col(tomo.IconEmblemDefault)
+	col(tomo.IconEmblemEncrypted)
+	col(tomo.IconEmblemFavorite)
+	col(tomo.IconEmblemImportant)
+	col(tomo.IconEmblemReadOnly)
+	col(tomo.IconEmblemShared)
+	col(tomo.IconEmblemSymbolicLink)
+	col(tomo.IconEmblemSynchronized)
+	col(tomo.IconEmblemSystem)
+	col(tomo.IconEmblemUnreadable)
+
+	row()
+	// places
+	col(tomo.IconPlaceDirectory)
+	col(tomo.IconPlaceRemote)
+	col(tomo.IconPlaceHome)
+	col(tomo.IconPlaceDownloads)
+	col(tomo.IconPlaceDesktop)
+	col(tomo.IconPlacePhotos)
+	col(tomo.IconPlaceBooks)
+	col(tomo.IconPlaceBookmarks)
+	col(tomo.IconPlaceTrash)
+	col(tomo.IconPlaceDocuments)
+	col(tomo.IconPlaceRepositories)
+	col(tomo.IconPlaceMusic)
+	col(tomo.IconPlaceArchives)
+	col(tomo.IconPlaceFonts)
+	col(tomo.IconPlaceBinaries)
+	col(tomo.IconPlaceVideos)
+	col(tomo.IconPlace3DObjects)
+	col(tomo.IconPlaceHistory)
+	col(tomo.IconPlacePreferences)
+
+	row()
+	// status: appointments
+	col(tomo.IconAppointmentMissed)
+	col(tomo.IconAppointmentSoon)
+	// status: dialogs
+	col(tomo.IconDialogError)
+	col(tomo.IconDialogInformation)
+	col(tomo.IconDialogPassword)
+	col(tomo.IconDialogQuestion)
+	col(tomo.IconDialogWarning)
+	// status: directories
+	col(tomo.IconDirectoryDragAccept)
+	col(tomo.IconDirectoryFull)
+	col(tomo.IconDirectoryOpen)
+	col(tomo.IconDirectoryVisiting)
+	// status: trash
+	col(tomo.IconTrashFull)
+	// status: resource
+	col(tomo.IconResourceLoading)
+	col(tomo.IconResourceMissing)
+	// status: mail
+	col(tomo.IconMailAttachment)
+	col(tomo.IconMailUnread)
+	col(tomo.IconMailReplied)
+	col(tomo.IconMailSigned)
+	col(tomo.IconMailSignedVerified)
+
+	row()
+	// status: network
+	col(tomo.IconCellularSignal0)
+	col(tomo.IconCellularSignal1)
+	col(tomo.IconCellularSignal2)
+	col(tomo.IconCellularSignal3)
+	col(tomo.IconWirelessSignal0)
+	col(tomo.IconWirelessSignal1)
+	col(tomo.IconWirelessSignal2)
+	col(tomo.IconWirelessSignal3)
+	col(tomo.IconNetworkError)
+	col(tomo.IconNetworkIdle)
+	col(tomo.IconNetworkOffline)
+	col(tomo.IconNetworkReceive)
+	col(tomo.IconNetworkTransmit)
+	col(tomo.IconNetworkTransmitReceive)
+	// status: print
+	col(tomo.IconPrintError)
+	col(tomo.IconPrintPrinting)
+	// status: security
+	col(tomo.IconSecurityHigh)
+	col(tomo.IconSecurityMedium)
+	col(tomo.IconSecurityLow)
+	// status: software
+	col(tomo.IconSoftwareUpdateAvailable)
+	col(tomo.IconSoftwareUpdateUrgent)
+	col(tomo.IconSoftwareInstalling)
+	// status: sync
+	col(tomo.IconSyncError)
+	col(tomo.IconSyncSynchronizing)
+	// status: tasks
+	col(tomo.IconTaskDue)
+	col(tomo.IconTaskPastDue)
+	// status: users
+	col(tomo.IconUserAvailable)
+	col(tomo.IconUserAway)
+	col(tomo.IconUserIdle)
+	col(tomo.IconUserOffline)
+
+	row()
+	// status: power
+	col(tomo.IconBattery0)
+	col(tomo.IconBattery1)
+	col(tomo.IconBattery2)
+	col(tomo.IconBattery3)
+	col(tomo.IconBrightness0)
+	col(tomo.IconBrightness1)
+	col(tomo.IconBrightness2)
+	col(tomo.IconBrightness3)
+	// status: media
+	col(tomo.IconVolume0)
+	col(tomo.IconVolume1)
+	col(tomo.IconVolume2)
+	col(tomo.IconVolume3)
+	col(tomo.IconPlaylistRepeat)
+	col(tomo.IconPlaylistShuffle)
+	// status: weather
+	col(tomo.IconWeatherClear)
+	col(tomo.IconWeatherClearNight)
+	col(tomo.IconWeatherFewClouds)
+	col(tomo.IconWeatherFewCloudsNight)
+	col(tomo.IconWeatherFog)
+	col(tomo.IconWeatherOvercast)
+	col(tomo.IconWeatherSevereAlert)
+	col(tomo.IconWeatherShowers)
+	col(tomo.IconWeatherShowersScattered)
+	col(tomo.IconWeatherSnow)
+	col(tomo.IconWeatherStorm)
+	
+	return source
+}
+
+type iconSet struct {
+	texturesSmall map[tomo.Icon] canvas.Texture
+	texturesLarge map[tomo.Icon] canvas.Texture
+}
+
+// New creates a new fallback icon set.
+func New () style.IconSet {
+	return new(iconSet)
+}
+
+func (this *iconSet) ensure () {
+	if this.texturesSmall != nil { return }
+	this.texturesSmall = generateSource(atlasSmallBytes, 16)
+	this.texturesLarge = generateSource(atlasLargeBytes, 32)
+}
+
+func (this *iconSet) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.Texture {
+	if size == tomo.IconSizeSmall {
+		return this.texturesSmall
+	} else {
+		return this.texturesLarge
+	}
+}
+
+func (this *iconSet) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
+	this.ensure()
+	source := this.selectSource(size)
+	if texture, ok := source[icon]; ok {
+		return texture
+	}
+	return nil
+}
+
+func (this *iconSet) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
+	this.ensure()
+	source := this.selectSource(size)
+	if mime == data.M("inode", "directory") {
+		return source[tomo.IconPlaceDirectory]
+	} else {
+		return source[tomo.Icon("File")]
+	}
+}

internal/icons/xdg/icon.go

@@ -0,0 +1,183 @@
+package xdgIcons
+
+import "os"
+import "fmt"
+import "log"
+import "image"
+import "regexp"
+import "strings"
+import _ "image/png"
+import "git.tebibyte.media/tomo/tomo"
+import "git.tebibyte.media/tomo/tomo/data"
+import "git.tebibyte.media/tomo/tomo/canvas"
+import "git.tebibyte.media/tomo/backend/style"
+import xdgIconTheme "git.tebibyte.media/tomo/xdg/icon-theme"
+
+type iconTheme struct {
+	xdg xdgIconTheme.Theme
+	fallback       style.IconSet
+	texturesSmall  map[tomo.Icon] canvas.Texture
+	texturesMedium map[tomo.Icon] canvas.Texture
+	texturesLarge  map[tomo.Icon] canvas.Texture
+}
+
+func FindThemeWarn (name string, fallback style.IconSet, path ...string) (style.IconSet, error) {
+	this := &iconTheme {
+		fallback:       fallback,
+		texturesLarge:  make(map[tomo.Icon] canvas.Texture),
+		texturesMedium: make(map[tomo.Icon] canvas.Texture),
+		texturesSmall:  make(map[tomo.Icon] canvas.Texture),
+	}
+	
+	xdg, err := xdgIconTheme.FindThemeWarn(name, path...)
+	if err != nil { return nil, err }
+	this.xdg = xdg
+	
+	return this, nil
+}
+
+func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.Texture {
+	switch size {
+	case tomo.IconSizeMedium: return this.texturesMedium
+	case tomo.IconSizeLarge:  return this.texturesLarge
+	default:                  return this.texturesSmall
+	}
+}
+
+func (this *iconTheme) xdgIcon (name string, size tomo.IconSize) (canvas.Texture, bool) {
+	// TODO use scaling factor instead of 1
+	// find icon file
+	icon, err := this.xdg.FindIcon(name, iconSizePixels(size), 1, xdgIconTheme.PNG)
+	if err != nil { return nil, false }
+
+	// open icon file
+	iconFile, err := os.Open(icon.Path)
+	if err != nil {
+		// this failing indicates a broken icon theme
+		log.Printf("nasin: icon file '%s' is inaccessible: %v\n", icon.Path, err)
+		return nil, false
+	}
+
+	iconImage, _, err := image.Decode(iconFile)
+	if err != nil {
+		// this failing indicates a broken icon theme
+		log.Printf("nasin: icon file '%s' is broken: %v\n", icon.Path, err)
+		return nil, false
+	}
+
+	return tomo.NewTexture(iconImage), true
+}
+
+func (this *iconTheme) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
+	source := this.selectSource(size)
+	texture, ok := source[icon]
+	if !ok {
+		texture = this.icon(icon, size)
+		source[icon] = texture
+	}
+
+	if texture == nil {
+		return this.fallback.Icon(icon, size)
+	} else {
+		return texture
+	}
+}
+
+func (this *iconTheme) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
+	icon := tomo.Icon(mime.String())
+	source := this.selectSource(size)
+	texture, ok := source[icon]
+	if !ok {
+		texture = this.mimeIcon(mime, size)
+		source[icon] = texture
+	}
+
+	if texture == nil {
+		return this.fallback.MimeIcon(mime, size)
+	} else {
+		return texture
+	}
+}
+
+func (this *iconTheme) icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
+	if texture, ok := this.xdgIcon(XdgIconName(icon), size); ok {
+		return texture
+	}
+	if texture, ok := this.xdgIcon(XdgIconName(generalizeIcon(icon)), size); ok {
+		return texture
+	}
+	return nil
+}
+
+func (this *iconTheme) mimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
+	if texture, ok := this.xdgIcon(xdgFormatMime(mime), size); ok {
+		return texture
+	}
+	if texture, ok := this.xdgIcon(xdgFormatMime(generalizeMimeType(mime)), size); ok {
+		return texture
+	}
+	if texture, ok := this.xdgIcon(xdgFormatMime(data.M("text", "x-generic")), size); ok {
+		return texture
+	}
+	return nil
+}
+
+var kebabMatchFirstCap = regexp.MustCompile("(.)([A-Z][a-z]+)")
+var kebabMatchAllCaps  = regexp.MustCompile("([a-z0-9])([A-Z])")
+
+// XdgIconName returns the best XDG name for the given icon.
+func XdgIconName (icon tomo.Icon) string {
+	if name, ok := xdgIconNames[icon]; ok {
+		return name
+	}
+
+	name := kebabMatchFirstCap.ReplaceAllString(string(icon), "${1}-${2}")
+	name  = kebabMatchAllCaps.ReplaceAllString(string(name), "${1}-${2}")
+	return strings.ToLower(name)
+}
+
+func generalizeIcon (icon tomo.Icon) tomo.Icon {
+	name := string(icon)
+	switch {
+	case strings.HasPrefix(name, "Application"): return tomo.IconApplication
+	case strings.HasPrefix(name, "Preferences"): return tomo.IconPreferences
+	case strings.HasPrefix(name, "Device"):      return tomo.IconDevice
+	case strings.HasPrefix(name, "Hardware"):    return tomo.IconHardware
+	case strings.HasPrefix(name, "Storage"):     return tomo.IconStorageHardDisk
+	case strings.HasPrefix(name, "Input"):       return tomo.IconInputMouse
+	case strings.HasPrefix(name, "Network"):     return tomo.IconNetworkWired
+	case strings.HasPrefix(name, "Place"):       return tomo.IconPlaceDirectory
+	case strings.HasPrefix(name, "Directory"):   return tomo.IconPlaceDirectory
+	case strings.HasPrefix(name, "Trash"):       return tomo.IconPlaceTrash
+	case strings.HasPrefix(name, "Help"):        return tomo.IconHelpContents
+	}
+
+	switch icon {
+	case tomo.IconCellularSignal0: return tomo.IconWirelessSignal0
+	case tomo.IconCellularSignal1: return tomo.IconWirelessSignal1
+	case tomo.IconCellularSignal2: return tomo.IconWirelessSignal2
+	case tomo.IconCellularSignal3: return tomo.IconWirelessSignal3
+	}
+
+	return icon
+}
+
+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 {
+	case tomo.IconSizeMedium: return 24
+	case tomo.IconSizeLarge:  return 48
+	default:                  return 16
+	}
+}

internal/icons/xdg/xdgiconname.go

@@ -0,0 +1,136 @@
+package xdgIcons
+
+import "git.tebibyte.media/tomo/tomo"
+
+// icons that can't be directly translated with regex
+var xdgIconNames = map[tomo.Icon] string {
+	tomo.IconUnknown:                      "image-missing",
+	tomo.IconFileNew:                      "document-new",
+	tomo.IconDirectoryNew:                 "folder-new",
+	tomo.IconFileOpen:                     "document-open",
+	tomo.IconFileOpenRecent:               "document-open-recent",
+	tomo.IconFilePageSetup:                "document-page-setup",
+	tomo.IconFilePrint:                    "document-print",
+	tomo.IconFilePrintPreview:             "document-print-preview",
+	tomo.IconFilePermissions:              "document-permissions",        // non-standard
+	tomo.IconFileProperties:               "document-properties",
+	tomo.IconFileRename:                   "document-rename",             // non-standard
+	tomo.IconFileRevert:                   "document-revert",
+	tomo.IconFileSave:                     "document-save",
+	tomo.IconFileSaveAs:                   "document-save-as",
+	tomo.IconFileSend:                     "document-send",
+	tomo.IconFormatAlignCenter:            "format-justify-center",
+	tomo.IconFormatAlignEven:              "format-justify-fill",
+	tomo.IconFormatAlignLeft:              "format-justify-left",
+	tomo.IconFormatAlignRight:             "format-justify-right",
+	tomo.IconMailReceive:                  "mail-send-receive",
+	tomo.IconValueIncrement:               "list-add",
+	tomo.IconValueDecrement:               "list-remove",
+	tomo.IconValueReset:                   "value-reset",                 // non-standard
+	tomo.IconApplication:                  "system-run",
+	tomo.IconApplicationWebBrowser:        "web-browser",
+	tomo.IconApplicationMesssanger:        "internet-messanger",          // non-standard
+	tomo.IconApplicationPhone:             "accessories-phone",           // non-standard
+	tomo.IconApplicationMail:              "internet-mail-client",        // non-standard
+	tomo.IconApplicationTerminalEmulator:  "utilities-terminal",
+	tomo.IconApplicationFileBrowser:       "system-file-manager",
+	tomo.IconApplicationTextEditor:        "accessories-text-editor",
+	tomo.IconApplicationDocumentViewer:    "office-document-viewer",      // non-standard
+	tomo.IconApplicationWordProcessor:     "office-word-processor",       // non-standard
+	tomo.IconApplicationSpreadsheet:       "office-spreadsheet",          // non-standard
+	tomo.IconApplicationSlideshow:         "office-slideshow",            // non-standard
+	tomo.IconApplicationCalculator:        "accessories-calculator",
+	tomo.IconApplicationPreferences:       "preferences-system",
+	tomo.IconApplicationProcessManager:    "utilities-system-monitor",
+	tomo.IconApplicationSystemInformation: "distributor-logo",            // non-standard
+	tomo.IconApplicationManual:            "help-browser",
+	tomo.IconApplicationCamera:            "accessories-camera",          // non-standard
+	tomo.IconApplicationImageViewer:       "graphics-image-viewer",       // non-standard
+	tomo.IconApplicationMediaPlayer:       "audio-video-media-player",    // non-standard
+	tomo.IconApplicationImageEditor:       "graphics-image-editor",       // non-standard
+	tomo.IconApplicationAudioEditor:       "audio-audio-editor",          // non-standard
+	tomo.IconApplicationVideoEditor:       "video-video-editor",          // non-standard
+	tomo.IconApplicationClock:             "accessories-clock",           // non-standard
+	tomo.IconApplicationCalendar:          "accessories-calendar",        // non-standard
+	tomo.IconApplicationChecklist:         "accessories-checklist",       // non-standard
+	tomo.IconApplications:                 "applications-other",
+	tomo.IconPreferences:                  "preferences-other",
+	tomo.IconPreferencesNetwork:           "preferences-system-network",
+	tomo.IconDevice:                       "device",                      // non-standard
+	tomo.IconDeviceCamera:                 "camera-photo",
+	tomo.IconDeviceWebCamera:              "camera-web",
+	tomo.IconDeviceComputer:               "computer",
+	tomo.IconDevicePda:                    "pda",
+	tomo.IconDevicePhone:                  "phone",
+	tomo.IconDevicePrinter:                "printer",
+	tomo.IconDeviceScanner:                "scanner",
+	tomo.IconDeviceMultimediaPlayer:       "multimedia-player",
+	tomo.IconDeviceVideoDisplay:           "video-display",
+	tomo.IconDeviceAudioInput:             "audio-input-microphone",
+	tomo.IconDeviceAudioOutput:            "audio-speakers",
+	tomo.IconHardware:                     "card",                        // non-standard
+	tomo.IconHardwareCPU:                  "cpu",
+	tomo.IconHardwareGPU:                  "video-card",
+	tomo.IconHardwareRAM:                  "ram",
+	tomo.IconHardwareSoundCard:            "audio-card",
+	tomo.IconHardwareNetworkAdapter:       "network-card",
+	tomo.IconPowerBattery:                 "battery",
+	tomo.IconStorageHardDisk:              "drive-harddisk",
+	tomo.IconStorageFloppyDisk:            "media-floppy",
+	tomo.IconStorageSolidState:            "drive-solid",
+	tomo.IconStorageOptical:               "media-optical",
+	tomo.IconStorageFlashStick:            "media-removable",
+	tomo.IconStorageFlashCard:             "media-flash",
+	tomo.IconStorageMagneticTape:          "media-tape",
+	tomo.IconEmblemReadOnly:               "emblem-readonly",
+	tomo.IconPlaceDirectory:               "folder",
+	tomo.IconPlaceRemote:                  "folder-remote",
+	tomo.IconPlaceHome:                    "user-home",
+	tomo.IconPlaceDownloads:               "folder-downloads",            // common
+	tomo.IconPlaceDesktop:                 "user-desktop",
+	tomo.IconPlacePhotos:                  "folder-pictures",             // common
+	tomo.IconPlaceBooks:                   "folder-books",                // non-standard
+	tomo.IconPlaceBookmarks:               "user-bookmarks",
+	tomo.IconPlaceTrash:                   "user-trash",
+	tomo.IconPlaceDocuments:               "folder-documents",            // common
+	tomo.IconPlaceRepositories:            "folder-repositories",         // non-standard
+	tomo.IconPlaceMusic:                   "folder-music",                // common
+	tomo.IconPlaceArchives:                "folder-archives",             // non-standard
+	tomo.IconPlaceFonts:                   "folder-fonts",                // non-standard
+	tomo.IconPlaceBinaries:                "folder-executables",          // non-standard
+	tomo.IconPlaceVideos:                  "folder-videos",               // common
+	tomo.IconPlace3DObjects:               "folder-3d-objects",           // non-standard
+	tomo.IconPlaceHistory:                 "folder-history",              // non-standard
+	tomo.IconPlacePreferences:             "preferences-other",
+	tomo.IconDirectoryDragAccept:          "folder-drag-accept",
+	tomo.IconDirectoryFull:                "folder-full",
+	tomo.IconDirectoryOpen:                "folder-open",
+	tomo.IconDirectoryVisiting:            "folder-visiting",
+	tomo.IconTrashFull:                    "user-trash-full",
+	tomo.IconResourceLoading:              "image-loading",
+	tomo.IconResourceMissing:              "image-missing",
+	tomo.IconCellularSignal0:              "nm-signal-00",                // common
+	tomo.IconCellularSignal1:              "nm-signal-25",                // common
+	tomo.IconCellularSignal2:              "nm-signal-75",                // common
+	tomo.IconCellularSignal3:              "nm-signal-100",               // common
+	tomo.IconWirelessSignal0:              "wifi-signal-00",              // common
+	tomo.IconWirelessSignal1:              "wifi-signal-25",              // common
+	tomo.IconWirelessSignal2:              "wifi-signal-75",              // common
+	tomo.IconWirelessSignal3:              "wifi-signal-100",             // common
+	tomo.IconPrintError:                   "printer-error",
+	tomo.IconPrintPrinting:                "printer-printing",
+	tomo.IconBattery0:                     "battery-caution",
+	tomo.IconBattery1:                     "battery-low",
+	tomo.IconBattery2:                     "battery-good",                // common
+	tomo.IconBattery3:                     "battery-full",                // common
+	tomo.IconBrightness0:                  "brightness-dim",              // non-standard
+	tomo.IconBrightness1:                  "brightness-medium",           // non-standard
+	tomo.IconBrightness2:                  "brightness-bright",           // non-standard
+	tomo.IconBrightness3:                  "brightness-full",             // non-standard
+	tomo.IconVolume0:                      "audio-volume-muted",
+	tomo.IconVolume1:                      "audio-volume-low",
+	tomo.IconVolume2:                      "audio-volume-medium",
+	tomo.IconVolume3:                      "audio-volume-high",
+	tomo.IconPlaylistRepeat:               "media-playlist-repeat",
+	tomo.IconPlaylistShuffle:              "media-playlist-shuffle",
+}

internal/registrar/doc.go

@@ -0,0 +1,2 @@
+// Package registrar provides platform-dependent components at compile time.
+package registrar

internal/registrar/registrar_unix.go

@@ -0,0 +1,68 @@
+//go:build unix && (!darwin)
+package registrar
+
+import "os"
+import "log"
+import "git.tebibyte.media/tomo/tomo"
+import "git.tebibyte.media/tomo/backend/x"
+import "git.tebibyte.media/sashakoshka/goparse"
+import "git.tebibyte.media/tomo/nasin/internal/icons/xdg"
+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"
+
+type Registrar struct {
+	backend *x.Backend
+}
+
+func (this *Registrar) SetBackend () (tomo.Backend, error) {
+	backend, err := x.New()
+	if err != nil { return nil, err }
+	this.backend = backend.(*x.Backend)
+	tomo.SetBackend(backend)
+	return backend, nil
+}
+
+func (this *Registrar) SetTheme () error {
+	styleSheetName := os.Getenv("TOMO_STYLE_SHEET")
+	if styleSheetName != "" {
+		styl, _, err := tss.LoadFile(styleSheetName)
+		if err == nil {
+			this.backend.SetStyle(styl)
+			return nil
+		} else {
+			log.Printf (
+				"nasin: could not load style sheet '%s'\n%v",
+				styleSheetName, parse.Format(err))
+		}
+	}
+	
+	styl, _ := fallbackStyle.New()
+	this.backend.SetStyle(styl)
+	return nil
+}
+
+func (this *Registrar) SetIconSet () error {
+	iconSet := fallbackIcons.New()
+	iconSetName := os.Getenv("TOMO_XDG_ICON_THEME")
+	if iconSetName != "" {
+		xdgIconSet, err := xdgIcons.FindThemeWarn(iconSetName, iconSet)
+		if err == nil {
+			iconSet = xdgIconSet
+		} else {
+			log.Printf("nasin: could not load icon theme '%s': %v", iconSetName, err)
+		}
+	}
+	
+	this.backend.SetIconSet(iconSet)
+	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/registry/doc.go

@@ -1,2 +0,0 @@
-// Package registry provides platform-dependent components at compile time.
-package registry

internal/registry/registry_unix.go

@@ -1,10 +0,0 @@
-//go:build unix && (!darwin)
-package registry
-
-import "git.tebibyte.media/tomo/x"
-import "git.tebibyte.media/tomo/tomo"
-
-func Init () error {
-	tomo.Register(1, x.NewBackend)
-	return nil
-}

internal/styles/aluminum/aluminum.tss

@@ -0,0 +1,319 @@
+// 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;
+
+// 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                        ;
+
+*.* {
+	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;
+}
+
+*.Container[sunken] {
+	Border:  $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
+	Padding: 5 4 4 5;
+	Color:   $ColorSunken;
+}
+
+*.Container[outer] {
+	Color:   $ColorBackground;
+	Padding: 8;
+}
+
+*.Container[menu] {
+	Border: $BorderGap / 1, $BorderLifted / 1;
+	Color:  $ColorBackground;
+	Gap:    0;
+}
+
+*.Container[menu, torn] {
+	Border: ;
+	Color:  $ColorBackground;
+	Gap:    0;
+}
+
+*.Heading {
+	Align: middle middle;
+}
+
+*.Heading[menu] {
+	Align:   middle middle;
+	Padding: 4 8;
+}
+
+*.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[hovered] {
+	Color: $ColorDot;
+}
+
+*.MenuItem[focused] {
+	Color: $ColorDot;
+}
+
+*.File {
+	Color: #0000;
+}
+
+*.File[focused] {
+	Color: $ColorDot;
+}
+
+*.TearLine {
+	Border: $BorderTearPad / 3, $BorderTear / 1;
+}
+
+*.TearLine[hovered] {
+	Border: $BorderTearPadFocused / 3, $BorderTearFocused / 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;
+}
+
+*.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,649 @@
+package fallbackStyle
+
+import "io"
+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"
+
+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
+
+type closerCookie struct { io.Closer }
+func (cookie closerCookie) Close () { cookie.Closer.Close() }
+func newCloserCookie (closer io.Closer) event.Cookie {
+	return closerCookie { Closer: closer }
+}
+
+// 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(newCloserCookie(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")),
+
+	// *.Container[sunken]
+	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("", "Container"), "sunken"),
+
+	// *.Container[outer]
+	style.Ru(style.AS (
+		tomo.AttrColor { Color: tomo.ColorBackground },
+		tomo.AttrPadding(tomo.I(8)),
+	), tomo.R("", "Container"), "outer"),
+
+	// *.Container[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("", "Container"), "menu"),
+
+	// *.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"),
+	
+	// *.MenuItem[hovered]
+	style.Ru(style.AS (
+		tomo.AttrColor { Color: tomo.ColorAccent },
+	), tomo.R("", "MenuItem"), "hovered"),
+
+	// *.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"),
+
+	// *.TearLine[hovered]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(3),
+				Color: borderColorFocused,
+			},
+		},
+	), tomo.R("", "TearLine"), "hovered"),
+	
+	// *.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"),
+	
+	// *.TabbedContainer
+	style.Ru(style.AS (
+		tomo.AGap(0, 0),
+	), tomo.R("", "TabbedContainer")),
+	
+	// *.TabRow
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(1, 1, 0, 1),
+				Color: borderColorOutline,
+			},
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 1),
+				Color: borderColorEngraved,
+			},
+		},
+		tomo.AttrGap { X: 0, Y: 0 },
+		tomo.AttrColor { Color: colorGutter },
+		tomo.AttrPadding(tomo.I(1, 0, 0, 0)),
+	), tomo.R("", "TabRow")),
+	
+	// *.TabSpacer[left]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(0, 0, 1, 0),
+				Color: borderColorEngraved,
+			},
+			tomo.Border {
+				Width: tomo.I(0, 0, 1, 0),
+				Color: borderColorOutline,
+			},
+		},
+		tomo.AttrMinimumSize { X: 1 },
+	), tomo.R("", "TabSpacer")),
+	
+	// *.TabSpacer[right]
+	style.Ru(style.AS (
+		tomo.AttrBorder {
+			tomo.Border {
+				Width: tomo.I(1, 0, 0, 0),
+				Color: [4]color.Color {
+					colorGutter, colorGutter,
+					colorGutter, colorGutter,
+				},
+			},
+			tomo.Border {
+				Width: tomo.I(0, 0, 1, 0),
+				Color: borderColorEngraved,
+			},
+			tomo.Border {
+				Width: tomo.I(0, 0, 1, 1),
+				Color: borderColorOutline,
+			},
+			tomo.Border {
+				Width: tomo.I(0, 0, 0, 1),
+				Color: borderColorShade,
+			},
+		},
+		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 {
+					colorGutter, colorGutter,
+					colorGutter, colorGutter,
+				},
+			},
+			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,407 @@
+package tss
+
+import "os"
+import "io"
+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, closerCookie { Closer: 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
+	}
+}
+
+type closerCookie struct {
+	io.Closer
+}
+func (cookie closerCookie) Close () {
+	cookie.Closer.Close()
+}

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]*"

path.go

@@ -1,190 +1,32 @@
 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.
+// ApplicationUserConfigDir returns the directory path where an application can
-type FileWriter interface {
+// store its user configuration files.
-	fs.File
+func ApplicationUserConfigDir (app ApplicationDescription) (string, error) {
-	io.Writer
+	return userMkdirAll(app.ID, userConfigDir)
 }
 
-// ApplicationUserDataFS returns an FS that an application can use to store user
+// ApplicationUserCacheDir returns the directory path where an application can
-// data files.
+// store its user cache files.
-func ApplicationUserDataFS (app ApplicationDescription) (*FS, error) {
+func ApplicationUserCacheDir (app ApplicationDescription) (string, error) {
-	dataDir, err := userDataDir()
+	return userMkdirAll(app.ID, userCacheDir)
-	if err != nil { return nil, err }
-	return appFs(dataDir, app)
 }
 
-// ApplicationUserConfigFS returns an FS that an application can use to store
+func userMkdirAll (sub string, getter func () (string, error)) (string, error) {
-// user configuration files.
+	path, err := getter()
-func ApplicationUserConfigFS (app ApplicationDescription) (*FS, error) {
+	if err != nil { return "", err }
-	configDir, err := userConfigDir()
+	path = filepath.Join(path, sub)
-	if err != nil { return nil, err }
+	err = os.MkdirAll(path, 0700)
-	return appFs(configDir, app)
+	if err != nil { return "", err }
-}
+	return path, nil
-
-// 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,
-	}
-}
-
-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)
 }