We load fonts but it's a bit broken

application.go

@@ -65,6 +65,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 == "" {
@@ -133,8 +142,9 @@ func RunApplication (application Application) {
 	if err != nil { log.Fatalln("nasin: could not register backend:", err) }
 	err = tomo.Run(func () {
 		err := registrar.SetTheme()
-		err := registrar.SetIconSet()
 		if err != nil { log.Fatalln("nasin: could not set theme:", err) }
+		err = registrar.SetIconSet()
+		if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
 		err = application.Init()
 		if err != nil { log.Fatalln("nasin: could not run application:", err) }
 

go.mod

@@ -8,9 +8,12 @@ require (
 	git.tebibyte.media/tomo/objects v0.20.1
 	git.tebibyte.media/tomo/tomo v0.41.1
 	git.tebibyte.media/tomo/xdg v0.1.0
+	github.com/flopp/go-findfont v0.1.0
 	golang.org/x/image v0.11.0
 )
 
+replace git.tebibyte.media/tomo/tomo => /home/sashakoshka/Repos/tebibyte/tomo/tomo
+
 require (
 	git.tebibyte.media/tomo/typeset v0.7.1 // indirect
 	git.tebibyte.media/tomo/xgbkb v1.0.1 // indirect
@@ -18,4 +21,5 @@ require (
 	github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966 // indirect
 	github.com/jezek/xgb v1.1.1 // indirect
 	github.com/jezek/xgbutil v0.0.0-20231116234834-47f30c120111 // indirect
+	golang.org/x/text v0.12.0 // indirect
 )

go.sum

@@ -5,8 +5,6 @@ git.tebibyte.media/tomo/backend v0.5.1 h1:u3DLVcNWNdQsIxAEGcZ+kGG7zuew8tpPbyEFBx
 git.tebibyte.media/tomo/backend v0.5.1/go.mod h1:urnfu+D56Q9AOCZ/qp5YqkmlRRTIB5p9RbzBN7yIibQ=
 git.tebibyte.media/tomo/objects v0.20.1 h1:dCMMzaHmj7w016XtTb8QWvKMHVK2Fru/2a70NqApzHQ=
 git.tebibyte.media/tomo/objects v0.20.1/go.mod h1:hbBlQem9cNOt/G2rBvH/C94FT1oWgbtEftwg6ield9U=
-git.tebibyte.media/tomo/tomo v0.41.1 h1:XdbyF3VjsLj1Zppr70gUaufuh49hU32JQo2ENnw4PcA=
-git.tebibyte.media/tomo/tomo v0.41.1/go.mod h1:C9EzepS9wjkTJjnZaPBh22YvVPyA4hbBAJVU20Rdmps=
 git.tebibyte.media/tomo/typeset v0.7.1 h1:aZrsHwCG5ZB4f5CruRFsxLv5ezJUCFUFsQJJso2sXQ8=
 git.tebibyte.media/tomo/typeset v0.7.1/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
 git.tebibyte.media/tomo/xdg v0.1.0 h1:6G2WYPPiM2IXleCpKKHuJA34BxumwNWuLsUoX3yu5zA=
@@ -17,6 +15,8 @@ github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298 h1:1qlsVAQJ
 github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298/go.mod h1:D+QujdIlUNfa0igpNMk6UIvlb6C252URs4yupRUV4lQ=
 github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966 h1:lTG4HQym5oPKjL7nGs+csTgiDna685ZXjxijkne828g=
 github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966/go.mod h1:Mid70uvE93zn9wgF92A/r5ixgnvX8Lh68fxp9KQBaI0=
+github.com/flopp/go-findfont v0.1.0 h1:lPn0BymDUtJo+ZkV01VS3661HL6F4qFlkhcJN55u6mU=
+github.com/flopp/go-findfont v0.1.0/go.mod h1:wKKxRDjD024Rh7VMwoU90i6ikQRCr+JTHB5n4Ejkqvw=
 github.com/jezek/xgb v1.1.0/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
 github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
 github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
@@ -50,6 +50,7 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
 golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=

internal/registrar/registrar_unix.go

@@ -5,6 +5,7 @@ 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/style/tss"
 import "git.tebibyte.media/tomo/nasin/internal/icons/fallback"
@@ -23,8 +24,11 @@ func SetTheme () error {
 		styl, _, err := tss.LoadFile(styleSheetName)
 		if err == nil {
 			tomo.SetStyle(styl)
+			return nil
 		} else {
-			log.Printf("nasin: could not load style sheet '%s': %v", styleSheetName, err)
+			log.Printf (
+				"nasin: could not load style sheet '%s'\n%v",
+				styleSheetName, parse.Format(err))
 		}
 	}
 	

internal/style/aluminum.tss

@@ -0,0 +1,211 @@
+// Colors
+$ColorDot                   = #7391c0;
+$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                   / 1;
+$BorderEngraved       = #c3c3c5 #e3e3e3 #e9e9e9 #c2c2c2 / 1;
+$BorderGap            = #697c7c #566767 #566767 #697c7c / 1;
+$BorderLifted         = #f9fafc #c2c8d3 #a4afc0 #f5f6f8 / 1;
+$BorderLiftedFocused  = #f0f4f9 #b1baca #9aa6b7 #e4e9ee / 1;
+$BorderFocused        = #5f8bc4 #5f8bc4 #5f8bc4 #5f8bc4 / 1;
+$BorderTear           = $BorderEngraved;
+$BorderTearFocused    = #7f94b5 #ced7e4 #ced7e4 #7f94b5 / 1;
+$BorderTearPad        = #0000                           / 3;
+$BorderTearPadFocused = #7391c080                       / 3;
+$BorderInnerShadow    = #a4afc0                         / 1 0 0 1;
+$BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
+
+*.* {
+	TextColor: $ColorForeground;
+	DotColor:  $ColorDot;
+	Gap:       8;
+	Face:      "DMMono-Regular.ttf" 11;
+}
+
+*.Button {
+	Border:  $BorderEngraved, $BorderGap, $BorderLifted;
+	Padding: 4 8;
+	Color:   $ColorRaised;
+}
+
+*.Button[focused] {
+	Border:  $BorderEngraved, $BorderGap, $BorderLiftedFocused;
+	Padding: 4 8;
+	Color:   $ColorRaisedFocused;
+}
+
+*.Button[hovered] {
+	Color: $ColorRaisedHovered;
+}
+
+*.Button[pressed] {
+	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Padding: 5 8 4 9;
+	Color:   $ColorRaisedPressed;
+}
+
+*.TextInput {
+	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Padding: 5 4 4 5;
+	Color:   $ColorSunken;
+}
+
+*.TextInput[focused] {
+	Border: $BorderEngraved, $BorderFocused, $BorderInnerShadow;
+}
+
+*.TextView {
+	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Padding: 5 4 4 5;
+	Color:   $ColorSunken;
+}
+
+*.NumberInput {
+	Gap: 0;
+}
+
+*.Container[sunken] {
+	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Padding: 5 4 4 5;
+	Color:   $ColorSunken;
+}
+
+*.Container[outer] {
+	Color:   $ColorBackground;
+	Padding: 8;
+}
+
+*.Container[menu] {
+	Border: $BorderGap, $BorderLifted;
+	Color:  $ColorBackground;
+	Gap:    0;
+}
+
+*.Heading {
+	Align: middle middle;
+}
+
+*.Separator {
+	Border: $BorderEngraved;
+}
+
+*.Slider {
+	Border: $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Color:  $ColorGutter;
+}
+
+*.Slider[focused] {
+	Border: $BorderEngraved, $BorderFocused, $BorderInnerShadow;
+}
+
+*.Slider[hovered] {
+	Color: $ColorGutterHovered;
+}
+
+*.Slider[horizontal] {
+	MinimumSize: 48 0;
+}
+
+*.Slider[vertical] {
+	MinimumSize: 0 48;
+}
+
+*.SliderHandle {
+	Border:      $BorderOuterShadow, $BorderGap, $BorderLifted;
+	Color:       $ColorRaised;
+	MinimumSize: 12;
+}
+
+*.ScrollContainer {
+	Gap: 0;
+}
+
+*.Checkbox {
+	Border:      $BorderEngraved, $BorderGap, $BorderInnerShadow;
+	Color:       $ColorSunken;
+	Padding:     0 1 1 0;
+	MinimumSize: 19;
+}
+
+*.Checkbox[focused] {
+	Border:  $BorderEngraved, $BorderFocused, $BorderInnerShadow;
+	Color:   $ColorSunkenFocused;
+	Padding: 0;
+}
+
+*.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, $BorderTear;
+}
+
+*.TearLine[hovered] {
+	Border: $BorderTearPadFocused, $BorderTearFocused;
+}
+
+*.TearLine[focused] {
+	Border: $BorderTearPadFocused, $BorderTearFocused;
+}
+
+*.Calendar {
+	Border:  $BorderOuterShadow, $BorderGap;
+	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;
+}

internal/style/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/style/tss/build.go

@@ -0,0 +1,408 @@
+package tss
+
+import "os"
+import "fmt"
+import "image"
+import "errors"
+import "image/color"
+import "golang.org/x/image/font"
+import "github.com/flopp/go-findfont"
+import "git.tebibyte.media/tomo/tomo"
+import "golang.org/x/image/font/opentype"
+import "git.tebibyte.media/tomo/tomo/event"
+
+type styleBuilder struct {
+	sheet Sheet
+	fonts map[string]  *opentype.Font
+	faces map[faceKey] font.Face
+}
+
+type faceKey struct {
+	name string
+	size int
+}
+
+// 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) (*tomo.Style, event.Cookie, error) {
+	builder := &styleBuilder {
+		sheet: sheet,
+		fonts: make(map[string] *opentype.Font),
+		faces: make(map[faceKey] font.Face),
+	}
+	return builder.build()
+}
+
+func (this *styleBuilder) build () (*tomo.Style, event.Cookie, error) {
+	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 }
+	}
+	
+	cookies := []event.Cookie { }
+	style := &tomo.Style {
+		Rules: make([]tomo.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"),
+		},
+	}
+	
+	for index, rule := range this.sheet.Rules {
+		styleRule := tomo.Rule {
+			Role: tomo.Role {
+				Package: rule.Selector.Package,
+				Object:  rule.Selector.Object,
+			},
+			Tags: rule.Selector.Tags,
+			Set:  make(tomo.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)
+			}
+		}
+		style.Rules[index] = styleRule
+	}
+
+	// TODO include all the faces in this.faces (ONCE EACH) in the
+	// multicookie
+	
+	return style, 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":
+		// TODO load image from file
+	
+	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":
+		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() }
+		face, err := this.face(string(name), int(size))
+		if err != nil { return nil, nil, err }
+		return tomo.AFace(face), 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) face (name string, size int) (font.Face, error) {
+	key := faceKey { name: name, size: size }
+	face, ok := this.faces[key]
+	if ok { return face, nil }
+
+	font, ok := this.fonts[name]
+	if !ok {
+		path, err := findfont.Find(name)
+		if err != nil { return nil, err }		
+		file, err := os.Open(path)
+		if err != nil { return nil, err }
+		defer file.Close()
+		fnt, err := opentype.ParseReaderAt(file)
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf (
+				"could not load font %s: %v", path, err))
+		}
+		font = fnt
+		this.fonts[name] = font
+	}
+
+	face, err := opentype.NewFace(font, &opentype.FaceOptions {
+		Size: float64(size),
+		DPI:  96, // TODO: replace this with the actual DPI
+	})
+	if err != nil { return nil, err }
+	this.faces[key] = face
+	return face, nil
+}
+
+func buildAttrBorder (attr []ValueList) (tomo.Attr, error) {
+	borders := make([]tomo.Border, len(attr))
+	for index, list := range attr {
+		colors := make([]color.Color, 0, len(list))
+		sizes  := make([]int, 0, len(list))
+		
+		capturingSize := false
+		for _, value := range list {
+			if capturingSize {
+				if value, ok := value.(ValueNumber); ok {
+					sizes = append(sizes, int(value))
+					continue
+				}
+			} else {
+				if _, ok := value.(ValueCut); ok {
+					capturingSize = true
+					continue
+				}
+				if value, ok := value.(ValueColor); ok {
+					colors = append(colors, value)
+					continue
+				}
+			}
+			return nil, errors.New("malformed Border attribute value list")
+		}
+		
+		border := tomo.Border { }
+		if !copyBorderValue(border.Width[:], sizes) {
+			return nil, errors.New("malformed Border attribute width list")
+		}
+		if !copyBorderValue(border.Color[:], colors) {
+			return nil, errors.New("malformed Border attribute color list")
+		}
+		borders[index] = border
+	}
+	
+	return tomo.ABorder(borders...), nil
+}
+
+func copyBorderValue[T any, U ~[]T] (destination, source U) bool {
+	if len(source) > len(destination) { return false } 
+	switch len(source) {
+	case 1:
+		destination[0] = source[0]
+		destination[1] = source[0]
+		destination[2] = source[0]
+		destination[3] = source[0]
+		return true
+	case 2:
+		destination[0] = source[0]
+		destination[1] = source[1]
+		destination[2] = source[0]
+		destination[3] = source[1]
+		return true
+	case 4:
+		destination[0] = source[0]
+		destination[1] = source[1]
+		destination[2] = source[2]
+		destination[3] = source[3]
+		return true
+	default:
+		return false
+	}
+}
+

internal/style/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/style/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/style/tss/lex.go

@@ -19,6 +19,7 @@ const (
 	Star
 	Dot
 	Dollar
+	Slash
 	Color
 	Ident
 	Number
@@ -39,6 +40,7 @@ var tokenNames = map[parse.TokenKind] string {
 	Star: "Star",
 	Dot: "Dot",
 	Dollar: "Dollar",
+	Slash: "Slash",
 	Color: "Color",
 	Ident: "Ident",
 	Number: "Number",
@@ -115,6 +117,8 @@ func (this *lexer) next () (token parse.Token, err error) {
 				skipRune()
 				if err != nil { return }
 			}
+		} else {
+			token.Kind = Slash
 		}
 		if this.eof { err = nil; return }
 

internal/style/tss/parse.go

@@ -4,43 +4,6 @@ import "io"
 import "strconv"
 import "git.tebibyte.media/sashakoshka/goparse"
 
-type Sheet struct {
-	Variables map[string] ValueList
-	Rules     []Rule
-}
-
-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 ()
-}
-
-func (ValueNumber) value () { }
-type ValueNumber int
-
-func (ValueColor) value () { }
-type ValueColor uint32
-
-func (ValueString) value () { }
-type ValueString string
-
-func (ValueKeyword) value () { }
-type ValueKeyword string
-
-func (ValueVariable) value () { }
-type ValueVariable string
-
 type parser struct {
 	parse.Parser
 	sheet Sheet
@@ -105,9 +68,9 @@ func (this *parser) parseVariable () (string, ValueList, error) {
 	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 }
-	name := this.Value()
 	this.Next()
 	values, err := this.parseValueList()
 	if err != nil { return "", nil, err }
@@ -124,15 +87,18 @@ func (this *parser) parseRule () (Rule, error) {
 	selector, err := this.parseSelector()
 	if err != nil { return Rule { }, err }
 	rule.Selector = selector
-	err = this.Expect(LBracket)
+	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 { break }
-		_, exists := rule.Attrs[name]
-		if !exists {
+		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",
@@ -141,8 +107,6 @@ func (this *parser) parseRule () (Rule, error) {
 		rule.Attrs[name] = attr
 	}
 	
-	err = this.Expect(LBracket)
-	if err != nil { return Rule { }, err }
 	return rule, this.Next()
 }
 
@@ -167,20 +131,22 @@ func (this *parser) parseSelector () (Selector, error) {
 	}
 
 	// tags
-	err = this.ExpectNext(LBrace)
+	err = this.ExpectNext(LBracket)
 	if err == nil {
 		this.Next()
 		for {
-			err := this.Expect(Ident, String, RBrace)
+			err := this.Expect(Ident, String, RBracket)
 			if err != nil { return Selector { }, err }
-			if this.Is(RBrace) { break }
+			if this.Is(RBracket) { break       }
+			if this.Is(Comma)    { this.Next() }
 			selector.Tags = append(selector.Tags, this.Value())
-			err = this.ExpectNext(Comma, RBrace)
+			err = this.ExpectNext(Comma, RBracket)
 			if err != nil { return Selector { }, err }
 		}
+		this.Next()
 	}
 	
-	return selector, this.Next()
+	return selector, nil
 }
 
 func (this *parser) parseAttr () (string, []ValueList, error) {
@@ -195,18 +161,20 @@ func (this *parser) parseAttr () (string, []ValueList, error) {
 	this.Next()
 	for {
 		err := this.ExpectDesc (
-			"value, comma, or semicolon",
-			Number, Color, String, Ident, Dollar, Comma, Semicolon)
+			"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(Semicolon) { break       }
+		if this.Is(Comma)     { this.Next() }
 		valueList, err := this.parseValueList()
 		if err != nil { return "", nil, err }
 		attr = append(attr, valueList)
-		err = this.ExpectNext(Comma, Semicolon)
+		err = this.Expect(Comma, Semicolon)
 		if err != nil { return "", nil, err }
 	}
 	
-	return name, attr, this.Next()
+	return name, attr, nil
 }
 
 func (this *parser) parseValueList () (ValueList, error) {
@@ -214,7 +182,7 @@ func (this *parser) parseValueList () (ValueList, error) {
 	for {
 		err := this.ExpectDesc (
 			"value",
-			Number, Color, String, Ident, Dollar)
+			Number, Color, String, Ident, Dollar, Slash)
 		if err != nil { break }
 		switch this.Kind() {
 		case Number:
@@ -237,9 +205,12 @@ func (this *parser) parseValueList () (ValueList, error) {
 			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, this.Next()
+	return list, nil
 }
 
 func parseColor (runes []rune) (uint32, bool) {

internal/style/tss/tss.go

@@ -1,21 +1,79 @@
 package tss
 
-import "io"
 import "os"
 import "git.tebibyte.media/tomo/tomo"
 import "git.tebibyte.media/tomo/tomo/event"
 
-func BuildStyle (sheet Sheet) (*tomo.Style, event.Cookie, error) {
-	// TODO
-	return nil, nil, nil
+type Sheet struct {
+	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) (*tomo.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()
-	return Load(file)
+
+	sheet, err := Parse(Lex(name, file))
+	if err != nil { return nil, nil, err }
+	return BuildStyle(sheet)
 }