Compare commits
No commits in common. "main" and "v0.7.0" have entirely different histories.
73
README.md
@ -2,79 +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 builds an application framework on top of Tomo to ease and encourage the
|
||||
development of consistent and stable application software. It has these
|
||||
wonderful features, and more:
|
||||
|
||||
- Use the Application interface to create applications with relatively low
|
||||
boilerplate
|
||||
- CLI argument parsing and URI opening
|
||||
- Automatic setup/teardown of the backend
|
||||
- Advanced configuration system that can watch config files for changes
|
||||
- Default style and icon set, as well as a fully featured stylesheet language
|
||||
for creating custom styles, and support for XDG icon themes
|
||||
|
||||
## Getting Started
|
||||
Here is a basic "hello world" application, with explanations as comments:
|
||||
```go
|
||||
package main
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/tomo/nasin"
|
||||
import "git.tebibyte.media/tomo/objects"
|
||||
import "git.tebibyte.media/tomo/objects/layouts"
|
||||
|
||||
func main () {
|
||||
nasin.RunApplication(new(Application))
|
||||
}
|
||||
|
||||
type Application struct { }
|
||||
|
||||
// Describe returns the application's name and ID, and optionally what type of
|
||||
// application it is.
|
||||
func (this *Application) Describe () nasin.ApplicationDescription {
|
||||
return nasin.ApplicationDescription {
|
||||
// This is the name of the application. New application windows
|
||||
// will have this as their title by default.
|
||||
Name: "Example",
|
||||
// This is a "well-known" name, which typically is a domain name
|
||||
// owned by the application author.
|
||||
ID: "com.example.Example",
|
||||
}
|
||||
}
|
||||
|
||||
// Init performs initial setup of the application. Since this is a single-window
|
||||
// application that doesn't open any files, we create the window here.
|
||||
func (this *Application) Init () error {
|
||||
// Passing an empty rectangle when creating a new window will cause it
|
||||
// to auto-expand to fit the minimum size of its contents.
|
||||
window, err := nasin.NewApplicationWindow(this, image.Rectangle { })
|
||||
if err != nil { return err }
|
||||
// Here we create a new container with a basic vertical layout, place a
|
||||
// text label that says "Hello world!" in it, and set it as the root
|
||||
// object of the window.
|
||||
window.SetRoot(objects.NewOuterContainer (
|
||||
layouts.ContractVertical,
|
||||
objects.NewLabel("Hello world!")))
|
||||
window.SetVisible(true)
|
||||
// Nasin will not exit until all windows it is "waiting for" have
|
||||
// been closed.
|
||||
nasin.WaitFor(window)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Stop cleanly closes things like system resources or background tasks. We do
|
||||
// not have any here, so nothing is done.
|
||||
func (this *Application) Stop () { }
|
||||
```
|
||||
|
||||
To learn more, take a look at the [examples](examples) directory and the
|
||||
Nasin provides an easy way to write applications with Tomo. To get started, take
|
||||
a look at the [examples](examples) directory and the
|
||||
[online documentation](https://pkg.go.dev/git.tebibyte.media/tomo/nasin).
|
||||
|
||||
## Related Repositories
|
||||
Related repositories:
|
||||
- [Tomo API](https://git.tebibyte.media/tomo/tomo): The API that all other parts
|
||||
of the toolkit agree on
|
||||
- [Objects](https://git.tebibyte.media/tomo/objects): A standard collection of
|
||||
re-usable objects and other GUI components
|
||||
- [Backend](https://git.tebibyte.media/tomo/backend): The software responsible
|
||||
for managing and rendering things behind the scenes
|
||||
|
241
application.go
@ -1,15 +1,8 @@
|
||||
package nasin
|
||||
|
||||
import "fmt"
|
||||
import "log"
|
||||
import "flag"
|
||||
import "image"
|
||||
import "strings"
|
||||
import "net/url"
|
||||
import "path/filepath"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/objects"
|
||||
import "git.tebibyte.media/tomo/nasin/config"
|
||||
import "git.tebibyte.media/tomo/nasin/internal/registrar"
|
||||
|
||||
// Application represents an application object.
|
||||
@ -18,39 +11,7 @@ type Application interface {
|
||||
Describe () ApplicationDescription
|
||||
|
||||
// Init performs the initial setup of the application.
|
||||
Init () (error)
|
||||
|
||||
// Stop stops the application and does not return until all ongoing
|
||||
// operations have been completely shut down.
|
||||
Stop ()
|
||||
}
|
||||
|
||||
// ApplicationURLOpener is an application that can open a URL.
|
||||
type ApplicationURLOpener interface {
|
||||
Application
|
||||
|
||||
// OpenURL opens a new window with the contents of the given URL. If the
|
||||
// given URL is unsupported, it returns an error (for example, an image
|
||||
// viewer is not expected to open a text file).
|
||||
//
|
||||
// Applications should support the file:// scheme at the very least, and
|
||||
// should also support others like http:// and https:// if possible.
|
||||
OpenURL (*url.URL) error
|
||||
|
||||
// OpenNone is called when the application is launched without any URLs
|
||||
// to open.
|
||||
OpenNone () error
|
||||
}
|
||||
|
||||
// ApplicationFlagAdder is an application that supports reading command line
|
||||
// flags.
|
||||
type ApplicationFlagAdder interface {
|
||||
Application
|
||||
|
||||
// AddFlags is called before Init and given the default flag set that
|
||||
// Nasin uses to parse command line arguments. Note that when this
|
||||
// method is called, Tomo will not yet be initialized.
|
||||
AddFlags (*flag.FlagSet)
|
||||
Init () error
|
||||
}
|
||||
|
||||
// ApplicationDescription describes the name and type of an application.
|
||||
@ -70,15 +31,6 @@ 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 == "" {
|
||||
@ -124,191 +76,24 @@ type ApplicationRole string; const (
|
||||
RoleChecklist ApplicationRole = "Checklist"
|
||||
)
|
||||
|
||||
// Icon returns the icon ID for this role.
|
||||
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.
|
||||
// RunApplication is like tomo.Run, but runs an application. If something fails
|
||||
// to initialize, an error is written to the standard logger.
|
||||
func RunApplication (application Application) {
|
||||
// TODO: see #4
|
||||
|
||||
if application, ok := application.(ApplicationFlagAdder); ok {
|
||||
application.AddFlags(flag.CommandLine)
|
||||
}
|
||||
flag.Parse()
|
||||
|
||||
// open config
|
||||
globalConfig, err := ApplicationConfig(GlobalApplicationDescription())
|
||||
if err != nil { log.Fatalln("nasin: could not open config:", err) }
|
||||
currentGlobalConfig = globalConfig
|
||||
defer func () {
|
||||
globalConfig.Close()
|
||||
currentGlobalConfig = nil
|
||||
} ()
|
||||
styleConfigKey := "Style"
|
||||
iconSetConfigKey := "IconSet"
|
||||
|
||||
// registry
|
||||
// TODO: rebuild registry around the config
|
||||
reg := new(registrar.Registrar)
|
||||
backend, err := reg.SetBackend()
|
||||
if err != nil { log.Fatalln("nasin: could not register backend:", err) }
|
||||
err = reg.SetFaceSet()
|
||||
if err != nil { log.Fatalln("nasin: could not set face set:", err) }
|
||||
updateStyle := func () {
|
||||
value, err := globalConfig.GetString(styleConfigKey, "")
|
||||
if err != nil { log.Fatalln("nasin: could not set theme:", err) }
|
||||
err = reg.SetStyle(value)
|
||||
if err != nil { log.Fatalln("nasin: could not set theme:", err) }
|
||||
}
|
||||
updateIconSet := func () {
|
||||
value, err := globalConfig.GetString(iconSetConfigKey, "")
|
||||
if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
|
||||
err = reg.SetIconSet(value)
|
||||
if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
|
||||
}
|
||||
updateStyle()
|
||||
updateIconSet()
|
||||
|
||||
globalConfig.OnChange(func (key string) {
|
||||
switch key {
|
||||
case styleConfigKey: updateStyle()
|
||||
case iconSetConfigKey: updateIconSet()
|
||||
}
|
||||
err := registrar.Init()
|
||||
if err != nil { log.Fatal("nasin: could not init registry:", err) }
|
||||
err = tomo.Run(func () {
|
||||
err := application.Init()
|
||||
if err != nil { log.Fatal("nasin: could not run application:", err) }
|
||||
})
|
||||
|
||||
// init application
|
||||
err = application.Init()
|
||||
if err != nil { log.Fatalln("nasin: could not run application:", err) }
|
||||
|
||||
// open URLs
|
||||
args := flag.Args()
|
||||
applicationOpenUrls(application, args...)
|
||||
|
||||
if manager.count > 0 {
|
||||
err = backend.Run()
|
||||
if err != nil { log.Fatalln("nasin: could not run application:", err) }
|
||||
}
|
||||
application.Stop()
|
||||
if err != nil { log.Fatal("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. The window's icon will be automatically set by
|
||||
// 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, kind tomo.WindowKind, bounds image.Rectangle) (tomo.Window, error) {
|
||||
window, err := tomo.NewWindow(kind, bounds)
|
||||
// owned by the application.
|
||||
func NewApplicationWindow (application Application, bounds image.Rectangle) (tomo.MainWindow, error) {
|
||||
window, err := tomo.NewWindow(bounds)
|
||||
if err != nil { return nil, err }
|
||||
description := application.Describe()
|
||||
window.SetTitle(description.Name)
|
||||
|
||||
setApplicationWindowIcon(window, description)
|
||||
window.SetTitle(application.Describe().String())
|
||||
return window, nil
|
||||
}
|
||||
|
||||
// ApplicationConfig opens a new config for the specified application. It must
|
||||
// be closed when it is no longer needed.
|
||||
func ApplicationConfig (app ApplicationDescription) (config.ConfigCloser, error) {
|
||||
user, err := ApplicationUserConfigDir(app)
|
||||
if err != nil { return nil, err }
|
||||
user = filepath.Join(user, "config.conf")
|
||||
system, err := ApplicationSystemConfigDirs(app)
|
||||
if err != nil { return nil, err }
|
||||
for index, path := range system {
|
||||
system[index] = filepath.Join(path, "config.conf")
|
||||
}
|
||||
return config.NewConfig(user, system...)
|
||||
}
|
||||
|
||||
var currentGlobalConfig config.Config
|
||||
// GlobalConfig returns the global config. It contains options that apply to
|
||||
// Tomo/Nasin itself, such as the style sheet and the icon set. This is managed
|
||||
// by Nasin and must not be closed by the application.
|
||||
func GlobalConfig () config.Config {
|
||||
return currentGlobalConfig
|
||||
}
|
||||
|
||||
func errorPopupf (title, format string, v ...any) func (func ()) {
|
||||
return func (callback func ()) {
|
||||
dialog, err := objects.NewDialogOk (
|
||||
objects.DialogError, nil,
|
||||
title,
|
||||
fmt.Sprintf(format, v...),
|
||||
callback)
|
||||
if err != nil { log.Fatal(err) }
|
||||
dialog.SetVisible(true)
|
||||
WaitFor(dialog)
|
||||
}
|
||||
}
|
||||
|
||||
func applicationOpenUrls (app Application, args ...string) {
|
||||
application, ok := app.(ApplicationURLOpener)
|
||||
if !ok {
|
||||
if len(args) > 0 {
|
||||
log.Fatal("nasin: this application cannot open URLs")
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
openNone := func () bool {
|
||||
err := application.OpenNone()
|
||||
if err != nil {
|
||||
log.Fatalf("nasin: could not open main window: %v", err)
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
if len(args) <= 0 {
|
||||
openNone()
|
||||
return
|
||||
}
|
||||
|
||||
openedAny := false
|
||||
for _, arg := range flag.Args() {
|
||||
ur, err := url.Parse(arg)
|
||||
if err != nil {
|
||||
log.Fatalf (
|
||||
"nasin: invalid URL %v: %v",
|
||||
arg, err)
|
||||
}
|
||||
if ur.Scheme == "" {
|
||||
ur.Scheme = "file"
|
||||
}
|
||||
err = application.OpenURL(ur)
|
||||
if err != nil {
|
||||
errorPopupf(
|
||||
"Could Not Open URL",
|
||||
"Could not open %v: %v",
|
||||
arg, err,
|
||||
)(func () {
|
||||
if !openedAny {
|
||||
openNone()
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func setApplicationWindowIcon (window tomo.Window, description ApplicationDescription) {
|
||||
iconExists := func (icon tomo.Icon) bool {
|
||||
return icon.Texture(tomo.IconSizeMedium) != nil
|
||||
}
|
||||
|
||||
if iconExists(tomo.Icon(description.ID)) {
|
||||
window.SetIcon(tomo.Icon(description.ID))
|
||||
return
|
||||
}
|
||||
if iconExists(description.Role.Icon()) {
|
||||
window.SetIcon(description.Role.Icon())
|
||||
return
|
||||
}
|
||||
}
|
||||
|
@ -1,78 +0,0 @@
|
||||
# config
|
||||
Package config provides a configuration system for applications.
|
||||
|
||||
## Config File Location
|
||||
Config files are stored in standard operating system locations. Each application
|
||||
has exactly one user-level config directory within the user-level config
|
||||
location, and a system-level subdirectory in each of the system-level config
|
||||
locations (if applicable). Each subdirectory bears the application's well-known
|
||||
name as specified in ApplicationDescription. Each subdirectory contains a file
|
||||
called config.conf, which is where the actual config data is stored.
|
||||
|
||||
The user-level configuration file takes precendence over system configuration
|
||||
files, and system configuration files take precedence over eachother depending
|
||||
on what order they are specified in. How they are specified depends on the
|
||||
operating system.
|
||||
|
||||
### Linux, Most Unixes
|
||||
In terms of the XDG Base Directory Specification, an application with the
|
||||
well-known name com.example.Example would have its config files stored at
|
||||
`$XDG_CONFIG_DIRS/com.example.Example/config.conf`. On most systems where this
|
||||
specification is applicable, this will result in a file at
|
||||
`/etc/xdg/com.example.Example/config.conf` and another at
|
||||
`$HOME/.config/com.example.Example/config.conf`. The location for config files
|
||||
on systems that do not make use of this specification is yet to be determined.
|
||||
|
||||
## Config File Format
|
||||
The general format of the file is as follows:
|
||||
|
||||
- Encoded in UTF-8
|
||||
- Consists of lines, separated by \n, or \r\n
|
||||
- Lines can be any of these:
|
||||
- Blank line: has only whitespace
|
||||
- Comment: begins with a '#'
|
||||
- Entry: a key/value pair separated by an '=' sign
|
||||
|
||||
### Entries
|
||||
For entries, all whitespace on either side of the '=' sign, the key, or the
|
||||
value is ignored. The key may contain any letter or digit, as well as '-' and
|
||||
'.'. The value is always identified by its first rune (after the preliminary
|
||||
whitespace of course) and can be one of:
|
||||
|
||||
- String
|
||||
- Number
|
||||
- Bool
|
||||
|
||||
#### String
|
||||
A string can be either double-quoted, or any string of runes not identifiable
|
||||
as any other kind of value. Quoted strings are always unquoted when they are
|
||||
read. Either way, these escape sequences are supported, and resolved when they
|
||||
are read:
|
||||
|
||||
- '\\\\': a literal backslash
|
||||
- '\a': alert, bell
|
||||
- '\b': backspace
|
||||
- '\t': horizontal tab
|
||||
- '\n': line feed
|
||||
- '\v': vertical tab
|
||||
- '\f': form feed
|
||||
- '\r': carriage return
|
||||
- '\\"': double quote
|
||||
|
||||
Be aware that some unquoted strings, within reason, are subject to being read
|
||||
as some other value in the future. For example, if there were suddenly a
|
||||
third boolean value called glorble, the unquoted string glorble would be read
|
||||
as a boolean value instead of a string.
|
||||
|
||||
#### Number
|
||||
A number is a floating point value. It can be of the form:
|
||||
- Inf: positive infinity
|
||||
- -Inf: negative infinity
|
||||
- NaN: "not a number"
|
||||
- [0-9]+: a whole number
|
||||
- [0-9]+\.[0-9]*: a fractional number
|
||||
|
||||
#### Bool
|
||||
A bool is a boolean value. It can be one of:
|
||||
- true
|
||||
- false
|
159
config/config.go
@ -1,159 +0,0 @@
|
||||
// Package config provides a configuration system for applications.
|
||||
package config
|
||||
|
||||
import "fmt"
|
||||
import "math"
|
||||
import "strconv"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
|
||||
type configError string;
|
||||
func (err configError) Error () string { return string(err) }
|
||||
|
||||
const (
|
||||
// ErrClosed is returned when Get/Set/Reset is called after the config
|
||||
// has been closed.
|
||||
ErrClosed = configError("attempt to access a closed config")
|
||||
// ErrNonexistentEntry is returned when an entry was not found.
|
||||
ErrNonexistentEntry = configError("nonexistent entry")
|
||||
// ErrMalformedEntry is returned when a config entry could not be
|
||||
// parsed.
|
||||
ErrMalformedEntry = configError("malformed entry")
|
||||
// ErrMalformedKey is returned when a key has invalid runes.
|
||||
ErrMalformedKey = configError("malformed key")
|
||||
// ErrMalformedValue is returned when a value could not be parsed.
|
||||
ErrMalformedValue = configError("malformed value")
|
||||
// ErrMalformedString is returned when a string value could not be
|
||||
// parsed.
|
||||
ErrMalformedStringValue = configError("malformed string value")
|
||||
// ErrMalformedNumber is returned when a number value could not be
|
||||
// parsed.
|
||||
ErrMalformedNumberValue = configError("malformed number value")
|
||||
// ErrMalformedBool is returned when a boolean value could not be
|
||||
// parsed.
|
||||
ErrMalformedBoolValue = configError("malformed bool value")
|
||||
// ErrMalformedEscapeSequence us returned when an escape sequence could
|
||||
// not be parsed.
|
||||
ErrMalformedEscapeSequence = configError("malformed escape sequence")
|
||||
)
|
||||
|
||||
// Config provides access to an application's configuration, and can notify an
|
||||
// application of changes to it.
|
||||
type Config interface {
|
||||
// Get gets a value, first considering the user-level config file, and
|
||||
// then falling back to system level config files. If the value could
|
||||
// not be found anywhere, the specified fallback value is returned. If
|
||||
// the key is invalid, it returns nil, ErrMalformedKey.
|
||||
Get (key string, fallback Value) (Value, error)
|
||||
// GetString is like Get, but will only return strings. If the value is
|
||||
// not a string, it will return fallback.
|
||||
GetString (key string, fallback string) (string, error)
|
||||
// GetNumber is like Get, but will only return numbers. If the value is
|
||||
// not a number, it will return fallback.
|
||||
GetNumber (key string, fallback float64) (float64, error)
|
||||
// GetBool is like Get, but will only return booleans. If the value is
|
||||
// not a boolean, it will return fallback.
|
||||
GetBool (key string, fallback bool) (bool, error)
|
||||
// Set sets a value in the user-level config file. If the key is
|
||||
// invalid, it returns ErrMalformedKey. Note that calling this behavior
|
||||
// *will* cause a write to disk, and a read from disk for whatever is
|
||||
// watching the user file.
|
||||
Set (key string, value Value) error
|
||||
// Reset removes the value from the user-level config file, resetting it
|
||||
// to what is described by the system-level config files. If the key is
|
||||
// invalid, it returns ErrMalformedKey. Note that calling this behavior
|
||||
// *will* cause a write to disk if successful , and a read from disk for
|
||||
// whatever is watching the user file.
|
||||
Reset (key string) error
|
||||
// OnChange specifies a function to be called whenever a value is
|
||||
// changed. The callback is always run within the backend's event loop
|
||||
// using tomo.Do. This could have been a channel but I didn't want to do
|
||||
// that to people.
|
||||
OnChange (func (key string)) event.Cookie
|
||||
}
|
||||
|
||||
// ConfigCloser is a config with a Close behavior, which stops watching the
|
||||
// config file and causes any subsequent sets/gets to return errors. Anything
|
||||
// that receives a ConfigCloser must close it when done.
|
||||
type ConfigCloser interface {
|
||||
Config
|
||||
// Close closes the config, causing it to stop watching for changes.
|
||||
// Reads or writes to the config after this will return an error.
|
||||
Close () error
|
||||
}
|
||||
|
||||
var negativeZero = math.Copysign(0, -1)
|
||||
|
||||
// Value is a config value. Its String behavior produces a lossless and
|
||||
// syntactically valid representation of the value.
|
||||
type Value interface {
|
||||
value ()
|
||||
fmt.Stringer
|
||||
Equals (Value) bool
|
||||
}
|
||||
|
||||
// ValueString is a string value.
|
||||
type ValueString string
|
||||
var _ Value = ValueString("")
|
||||
func (ValueString) value () { }
|
||||
func (value ValueString) Equals (other Value) bool {
|
||||
other, ok := other.(ValueString)
|
||||
return ok && value == other
|
||||
}
|
||||
func (value ValueString) String () string {
|
||||
return fmt.Sprintf("\"%s\"", escape(string(value)))
|
||||
}
|
||||
|
||||
// ValueNumber is a number value.
|
||||
type ValueNumber float64
|
||||
var _ Value = ValueNumber(0)
|
||||
func (ValueNumber) value () { }
|
||||
func (value ValueNumber) Equals (other Value) bool {
|
||||
other, ok := other.(ValueNumber)
|
||||
return ok && value == other
|
||||
}
|
||||
func (value ValueNumber) String () string {
|
||||
number := float64(value)
|
||||
// the requirements I wrote said lossless in all cases. here's lossless
|
||||
// in all cases!
|
||||
switch {
|
||||
case math.IsInf(number, 0):
|
||||
if math.Signbit(number) {
|
||||
return "-Inf"
|
||||
} else {
|
||||
return "Inf"
|
||||
}
|
||||
|
||||
case math.IsNaN(number):
|
||||
return "NaN"
|
||||
|
||||
case number == 0, number == negativeZero:
|
||||
if math.Signbit(number) {
|
||||
return "-0"
|
||||
} else {
|
||||
return "0"
|
||||
}
|
||||
|
||||
case math.Round(number) == number:
|
||||
return strconv.FormatInt(int64(number), 10)
|
||||
|
||||
default:
|
||||
return strconv.FormatFloat(number, 'f', -1, 64)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ValueBool is a boolean value.
|
||||
var _ Value = ValueBool(false)
|
||||
type ValueBool bool
|
||||
func (ValueBool) value () { }
|
||||
func (value ValueBool) Equals (other Value) bool {
|
||||
other, ok := other.(ValueBool)
|
||||
return ok && value == other
|
||||
}
|
||||
func (value ValueBool) String () string {
|
||||
if value {
|
||||
return "true"
|
||||
} else {
|
||||
return "false"
|
||||
}
|
||||
}
|
@ -1,97 +0,0 @@
|
||||
package config
|
||||
|
||||
import "fmt"
|
||||
import "strings"
|
||||
// import "unicode"
|
||||
|
||||
var escapeCodeToRune = map[rune] rune {
|
||||
'\\': '\\',
|
||||
'a': '\a',
|
||||
'b': '\b',
|
||||
't': '\t',
|
||||
'n': '\n',
|
||||
'v': '\v',
|
||||
'f': '\f',
|
||||
'r': '\r',
|
||||
'"': '"',
|
||||
}
|
||||
|
||||
var runeToEscapeCode = map[rune] rune { }
|
||||
func init () {
|
||||
for code, char := range escapeCodeToRune {
|
||||
runeToEscapeCode[char] = code
|
||||
}
|
||||
}
|
||||
|
||||
func escape (str string) string {
|
||||
builder := strings.Builder { }
|
||||
for _, char := range str {
|
||||
code, escaped := runeToEscapeCode[char]
|
||||
switch {
|
||||
case escaped:
|
||||
fmt.Fprintf(&builder, "\\%c", code)
|
||||
// case !unicode.IsPrint(char):
|
||||
// fmt.Fprintf(&builder, "\\%o", char)
|
||||
default:
|
||||
builder.WriteRune(char)
|
||||
}
|
||||
}
|
||||
return builder.String()
|
||||
}
|
||||
|
||||
func unescape (str string) (string, bool) {
|
||||
runes := []rune(str)
|
||||
builder := strings.Builder { }
|
||||
|
||||
end := func () bool {
|
||||
return len(runes) < 1
|
||||
}
|
||||
next := func () {
|
||||
if !end() { runes = runes[1:] }
|
||||
}
|
||||
|
||||
for !end() {
|
||||
if runes[0] == '\\' {
|
||||
if end() { return "", false }
|
||||
next()
|
||||
char, isEscape := escapeCodeToRune[runes[0]]
|
||||
switch {
|
||||
case isEscape:
|
||||
builder.WriteRune(char)
|
||||
next()
|
||||
// case isOctalDigit(runes[0]):
|
||||
// char = 0
|
||||
// for !end() && isOctalDigit(runes[0]) {
|
||||
// char *= 8
|
||||
// char += runes[0] - '0'
|
||||
// next()
|
||||
// }
|
||||
// builder.WriteRune(char)
|
||||
default:
|
||||
return "", false
|
||||
}
|
||||
} else {
|
||||
builder.WriteRune(runes[0])
|
||||
next()
|
||||
}
|
||||
}
|
||||
return builder.String(), true
|
||||
}
|
||||
|
||||
func unquote (str string) (string, bool) {
|
||||
if len(str) < 2 { return "", false }
|
||||
if firstRune(str) != '"' { return "", false }
|
||||
if str[len(str) - 1] != '"' { return "", false }
|
||||
return str[1:len(str) - 1], true
|
||||
}
|
||||
|
||||
func isOctalDigit (char rune) bool {
|
||||
return char >= '0' && char <= '7'
|
||||
}
|
||||
|
||||
func firstRune (str string) rune {
|
||||
for _, char := range str {
|
||||
return char
|
||||
}
|
||||
return 0
|
||||
}
|
@ -1,22 +0,0 @@
|
||||
package config
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestEscape (test *testing.T) {
|
||||
expected := `\\\a\bhello\t\n\vworld!\f\r\"`
|
||||
got := escape("\\\a\bhello\t\n\vworld!\f\r\"")
|
||||
if got != expected {
|
||||
test.Fatalf("expected: [%s]\ngot:[%s]", expected, got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnescape (test *testing.T) {
|
||||
expected := "\\\a\bhello\t\n\vworld!\f\r\""
|
||||
got, ok := unescape(`\\\a\bhello\t\n\vworld!\f\r\"`)
|
||||
if !ok {
|
||||
test.Fatalf("text could not be unescaped")
|
||||
}
|
||||
if got != expected {
|
||||
test.Fatalf("expected: [%s]\ngot:[%s]", expected, got)
|
||||
}
|
||||
}
|
247
config/file.go
@ -1,247 +0,0 @@
|
||||
package config
|
||||
|
||||
import "io"
|
||||
import "fmt"
|
||||
import "math"
|
||||
import "bufio"
|
||||
import "errors"
|
||||
import "strconv"
|
||||
import "strings"
|
||||
import "unicode"
|
||||
|
||||
type line any
|
||||
type comment string
|
||||
type entry struct { key string; value Value }
|
||||
|
||||
var _ io.WriterTo = new(File)
|
||||
|
||||
// File represents a config file. It preserves the order of the lines, as well
|
||||
// as blank lines and comments.
|
||||
type File struct {
|
||||
lines []line
|
||||
keys map[string] int
|
||||
}
|
||||
|
||||
// NewFile creates a blank file with nothing in it.
|
||||
func NewFile () *File {
|
||||
return &File {
|
||||
keys: make(map[string] int),
|
||||
}
|
||||
}
|
||||
|
||||
// Parse parses a config file from a reader. This function operates on a
|
||||
// best-effort basis: A file will always be returned, and any errors encountered
|
||||
// will be joined together. For a description of the format, see the README.md
|
||||
// of this package.
|
||||
func Parse (reader io.Reader) (*File, error) {
|
||||
file := &File {
|
||||
keys: make(map[string] int),
|
||||
}
|
||||
errs := []error { }
|
||||
scanner := bufio.NewScanner(reader)
|
||||
|
||||
for scanner.Scan() {
|
||||
text := strings.TrimSpace(scanner.Text())
|
||||
switch {
|
||||
case text == "", strings.HasPrefix(text, "#"):
|
||||
file.lines = append(file.lines, comment(text))
|
||||
default:
|
||||
entry, err := parseEntry(text)
|
||||
if err == nil {
|
||||
file.keys[entry.key] = len(file.lines)
|
||||
file.lines = append(file.lines, entry)
|
||||
} else {
|
||||
errs = append (errs, err )
|
||||
}
|
||||
}
|
||||
}
|
||||
errs = append(errs, scanner.Err())
|
||||
return file, errors.Join(errs...)
|
||||
}
|
||||
|
||||
func parseEntry (str string) (entry, error) {
|
||||
key, value, ok := strings.Cut(str, "=")
|
||||
if !ok { return entry { }, ErrMalformedEntry }
|
||||
|
||||
key = strings.TrimSpace(key)
|
||||
if !KeyValid(key) { return entry { }, ErrMalformedKey }
|
||||
|
||||
value = strings.TrimSpace(value)
|
||||
parsedValue, err := ParseValue(value)
|
||||
if err != nil { return entry { }, err }
|
||||
|
||||
return entry { key: key, value: parsedValue }, nil
|
||||
}
|
||||
|
||||
// ParseValue parses a value from a string. For any Value v,
|
||||
// ParseValue(v.String()) should hold data exactly equal to v. This function
|
||||
// does not trim whitespace.
|
||||
func ParseValue (str string) (Value, error) {
|
||||
first := firstRune(str)
|
||||
switch {
|
||||
case str == "":
|
||||
return ValueString(""), nil
|
||||
case first == '"':
|
||||
value, ok := unescape(str)
|
||||
if !ok { return nil, ErrMalformedEscapeSequence }
|
||||
value, ok = unquote(value)
|
||||
if !ok { return nil, ErrMalformedStringValue }
|
||||
return ValueString(value), nil
|
||||
case first == '-' || (first >= '0' && first <= '9'):
|
||||
value, err := strconv.ParseFloat(str, 64)
|
||||
if err != nil { return nil, ErrMalformedNumberValue }
|
||||
return ValueNumber(value), nil
|
||||
case str == "false":
|
||||
return ValueBool(false), nil
|
||||
case str == "true":
|
||||
return ValueBool(true), nil
|
||||
case str == "Inf":
|
||||
return ValueNumber(math.Inf(1)), nil
|
||||
case str == "NaN":
|
||||
return ValueNumber(math.NaN()), nil
|
||||
default:
|
||||
value, ok := unescape(str)
|
||||
if !ok { return nil, ErrMalformedEscapeSequence }
|
||||
return ValueString(value), nil
|
||||
}
|
||||
}
|
||||
|
||||
// Has returns whether the key exists. If the key is invalid, it returns false,
|
||||
// ErrMalformedKey.
|
||||
func (this *File) Has (key string) (bool, error) {
|
||||
if !KeyValid(key) { return false, ErrMalformedKey }
|
||||
if index, ok := this.keys[key]; ok {
|
||||
if _, ok := this.lines[index].(entry); ok {
|
||||
return true, nil
|
||||
}
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
|
||||
// Get gets the keyed value. If the value is unspecified, it returns nil,
|
||||
// ErrNonexistentEntry. If the key is invalid, it returns nil, ErrMalformedKey.
|
||||
func (this *File) Get (key string) (Value, error) {
|
||||
if !KeyValid(key) { return nil, ErrMalformedKey }
|
||||
if index, ok := this.keys[key]; ok {
|
||||
if lin, ok := this.lines[index].(entry); ok {
|
||||
return lin.value, nil
|
||||
}
|
||||
}
|
||||
return nil, ErrNonexistentEntry
|
||||
}
|
||||
|
||||
// Set sets a value. If the key is invalid, it returns ErrMalformedKey.
|
||||
func (this *File) Set (key string, value Value) error {
|
||||
if !KeyValid(key) { return ErrMalformedKey }
|
||||
ent := entry {
|
||||
key: key,
|
||||
value: value,
|
||||
}
|
||||
if index, ok := this.keys[key]; ok {
|
||||
this.lines[index] = ent
|
||||
return nil
|
||||
}
|
||||
this.keys[key] = len(this.lines)
|
||||
this.lines = append(this.lines, ent)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Reset removes the value from the file. If the value is set again, it will be
|
||||
// added back at the same location. Note that because of this, the positions of
|
||||
// lines are not forgotten until the file is written and reloaded. This is why
|
||||
// the method is called Reset and not Remove. If the key is invalid, it returns
|
||||
// ErrMalformedKey.
|
||||
func (this *File) Reset (key string) error {
|
||||
if !KeyValid(key) { return ErrMalformedKey }
|
||||
for index, lin := range this.lines {
|
||||
if lin, ok := lin.(entry); ok {
|
||||
if lin.key == key {
|
||||
this.lines[index] = nil
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Map creates and returns a map of keys to values.
|
||||
func (this *File) Map () map[string] Value {
|
||||
mp := make(map[string] Value)
|
||||
for key, index := range this.keys {
|
||||
if lin, ok := this.lines[index].(entry); ok {
|
||||
mp[key] = lin.value
|
||||
}
|
||||
}
|
||||
return mp
|
||||
}
|
||||
|
||||
// Diff returns a set of keys that are different from the other file.
|
||||
func (this *File) Diff (other *File) map[string] struct { } {
|
||||
diff := make(map[string] struct { })
|
||||
|
||||
// - keys only we have
|
||||
// - keys we both have, but are different
|
||||
for key, index := range this.keys {
|
||||
thisEntry, ok := this.lines[index].(entry)
|
||||
if !ok { continue }
|
||||
|
||||
otherIndex, ok := other.keys[key]
|
||||
if !ok {
|
||||
diff[key] = struct { } { }
|
||||
continue
|
||||
}
|
||||
otherEntry, ok := other.lines[otherIndex].(entry)
|
||||
if !ok {
|
||||
diff[key] = struct { } { }
|
||||
continue
|
||||
}
|
||||
|
||||
if !thisEntry.value.Equals(otherEntry.value) {
|
||||
diff[key] = struct { } { }
|
||||
}
|
||||
}
|
||||
|
||||
// - keys only they have
|
||||
for key := range other.keys {
|
||||
if otherHas, _ := other.Has(key); !otherHas {
|
||||
continue
|
||||
}
|
||||
if thisHas, _ := this.Has(key); !thisHas {
|
||||
diff[key] = struct { } { }
|
||||
}
|
||||
}
|
||||
|
||||
return diff
|
||||
}
|
||||
|
||||
// WriteTo writes the data in this file to an io.Writer.
|
||||
func (this *File) WriteTo (writer io.Writer) (n int64, err error) {
|
||||
for _, lin := range this.lines {
|
||||
nint := 0
|
||||
switch lin := lin.(type) {
|
||||
case comment:
|
||||
nint, err = fmt.Fprintln(writer, string(lin))
|
||||
case entry:
|
||||
nint, err = fmt.Fprintf(writer, "%s=%v\n", lin.key, lin.value)
|
||||
}
|
||||
n += int64(nint)
|
||||
if err != nil { return n, err }
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
// KeyValid returns whether a key contains only valid runes. They are:
|
||||
// - Letters
|
||||
// - Digits
|
||||
// - '-'
|
||||
// - '.'
|
||||
func KeyValid (key string) bool {
|
||||
for _, char := range key {
|
||||
valid :=
|
||||
char == '.' ||
|
||||
char == '-' ||
|
||||
unicode.IsLetter(char) ||
|
||||
unicode.IsDigit(char)
|
||||
if !valid { return false }
|
||||
}
|
||||
return true
|
||||
}
|
@ -1,222 +0,0 @@
|
||||
package config
|
||||
|
||||
import "math"
|
||||
import "maps"
|
||||
import "strings"
|
||||
import "testing"
|
||||
|
||||
func TestParseEntryUnquotedString (test *testing.T) {
|
||||
testParseEntry(test, "stringValue = Unquoted\\nString", "stringValue", ValueString("Unquoted\nString"))
|
||||
}
|
||||
|
||||
func TestParseEntryQuotedString (test *testing.T) {
|
||||
testParseEntry(test, "stringValue = \"Quoted\\nString\"", "stringValue", ValueString("Quoted\nString"))
|
||||
}
|
||||
|
||||
func TestParseEntryNumber (test *testing.T) {
|
||||
testParseEntry(test, "numberValue = -349.29034", "numberValue", ValueNumber(-349.29034))
|
||||
}
|
||||
|
||||
func TestParseEntryNumberInf (test *testing.T) {
|
||||
testParseEntry(test, "numberValue = Inf", "numberValue", ValueNumber(math.Inf(1)))
|
||||
}
|
||||
|
||||
func TestParseEntryNumberNegativeInf (test *testing.T) {
|
||||
testParseEntry(test, "numberValue = -Inf", "numberValue", ValueNumber(math.Inf(-1)))
|
||||
}
|
||||
|
||||
func TestParseEntryNumberNaN (test *testing.T) {
|
||||
testParseEntry(test, "numberValue = NaN", "numberValue", ValueNumber(math.NaN()))
|
||||
}
|
||||
|
||||
func TestParseEntryBoolTrue (test *testing.T) {
|
||||
testParseEntry(test, "boolValue = true", "boolValue", ValueBool(true))
|
||||
}
|
||||
|
||||
func TestParseEntryBoolFalse (test *testing.T) {
|
||||
testParseEntry(test, "boolValue = false", "boolValue", ValueBool(false))
|
||||
}
|
||||
|
||||
func TestParseEntryComplexKey (test *testing.T) {
|
||||
testParseEntry (
|
||||
test, "--Something.OtherThing...another-Thing-=value",
|
||||
"--Something.OtherThing...another-Thing-", ValueString("value"))
|
||||
}
|
||||
|
||||
func TestParse (test *testing.T) {
|
||||
testParse(test,
|
||||
` thing =something
|
||||
# comment
|
||||
|
||||
otherThing = otherValue
|
||||
otherThing = otherValue1
|
||||
otherThing = otherValue2 # not a comment
|
||||
`,
|
||||
`thing="something"
|
||||
# comment
|
||||
|
||||
otherThing="otherValue"
|
||||
otherThing="otherValue1"
|
||||
otherThing="otherValue2 # not a comment"
|
||||
`)
|
||||
}
|
||||
|
||||
func TestGetValue (test *testing.T) {
|
||||
file := parseFileString(test,
|
||||
`key=askdhj
|
||||
# some comment
|
||||
key = value
|
||||
key1 = 7`)
|
||||
got, err := file.Get("key")
|
||||
if err != nil { test.Fatal(err) }
|
||||
testValueString(test, got, `"value"`)
|
||||
}
|
||||
|
||||
func TestModifyValue (test *testing.T) {
|
||||
file := parseFileString(test,
|
||||
`key=askdhj
|
||||
# some comment
|
||||
key = value
|
||||
key1 = 7`)
|
||||
err := file.Set("key", ValueNumber(324980.2349))
|
||||
if err != nil { test.Fatal(err) }
|
||||
testFileString(test, file,
|
||||
`key="askdhj"
|
||||
# some comment
|
||||
key=324980.2349
|
||||
key1=7
|
||||
`)
|
||||
}
|
||||
|
||||
func TestResetValue (test *testing.T) {
|
||||
file := parseFileString(test,
|
||||
`key=askdhj
|
||||
# some comment
|
||||
key = value
|
||||
|
||||
key1 = 7`)
|
||||
err := file.Reset("key")
|
||||
if err != nil { test.Fatal(err) }
|
||||
testFileString(test, file,
|
||||
`# some comment
|
||||
|
||||
key1=7
|
||||
`)
|
||||
}
|
||||
|
||||
func TestDiffNone (test *testing.T) {
|
||||
str := `
|
||||
thing = something
|
||||
|
||||
otherThing = otherValue
|
||||
# comment
|
||||
otherThing = true
|
||||
otherThing = 234
|
||||
|
||||
yetAnotherThing = 0.23498
|
||||
`
|
||||
file1 := parseFileString(test, str)
|
||||
file2 := parseFileString(test, str)
|
||||
diff := file1.Diff(file2)
|
||||
if len(diff) != 0 {
|
||||
test.Fatalf("diff not empty:\n%v", diff)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiffReset (test *testing.T) {
|
||||
file1 := parseFileString(test,
|
||||
`key4=0
|
||||
key1=value1
|
||||
keyToDelete=true
|
||||
# comment
|
||||
key2=34`)
|
||||
file2 := parseFileString(test,
|
||||
`key1=value2
|
||||
key2=34
|
||||
anotherKeyToDelete=false
|
||||
# comment
|
||||
|
||||
key3=0.2`)
|
||||
file1.Reset("keyToDelete")
|
||||
file2.Reset("anotherKeyToDelete")
|
||||
diff := file1.Diff(file2)
|
||||
correct := map[string] struct { } {
|
||||
"key1": struct { } { },
|
||||
"key3": struct { } { },
|
||||
"key4": struct { } { },
|
||||
}
|
||||
if !maps.Equal(diff, correct) {
|
||||
test.Error("diffs do not match")
|
||||
test.Errorf("EXPECTED:\n%v", correct)
|
||||
test.Errorf("GOT:\n%v", diff)
|
||||
test.Fail()
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiff (test *testing.T) {
|
||||
file1 := parseFileString(test,
|
||||
`key4=0
|
||||
key1=value1
|
||||
# comment
|
||||
key2=34`)
|
||||
file2 := parseFileString(test,
|
||||
`key1=value2
|
||||
key2=34
|
||||
# comment
|
||||
|
||||
key3=0.2`)
|
||||
diff := file1.Diff(file2)
|
||||
correct := map[string] struct { } {
|
||||
"key1": struct { } { },
|
||||
"key3": struct { } { },
|
||||
"key4": struct { } { },
|
||||
}
|
||||
if !maps.Equal(diff, correct) {
|
||||
test.Error("diffs do not match")
|
||||
test.Errorf("EXPECTED:\n%v", correct)
|
||||
test.Errorf("GOT:\n%v", diff)
|
||||
test.Fail()
|
||||
}
|
||||
}
|
||||
|
||||
func testParseEntry (test *testing.T, str string, key string, value Value) {
|
||||
ent, err := parseEntry(str)
|
||||
if err != nil { test.Fatal(err) }
|
||||
if ent.key != key {
|
||||
test.Fatalf("expected key: [%s]\ngot key: [%s]", key, ent.key)
|
||||
}
|
||||
if ent.value.String() != value.String() {
|
||||
test.Fatalf("expected value: [%s]\ngot value: [%s]", value.String(), ent.value.String())
|
||||
}
|
||||
}
|
||||
|
||||
func testParse (test *testing.T, str, correct string) {
|
||||
if correct == "" { correct = str }
|
||||
testFileString(test, parseFileString(test, str), correct)
|
||||
}
|
||||
|
||||
func parseFileString (test *testing.T, str string) *File {
|
||||
file, err := Parse(strings.NewReader(str))
|
||||
if err != nil { test.Fatal(err) }
|
||||
return file
|
||||
}
|
||||
|
||||
func testFileString (test *testing.T, file *File, correct string) {
|
||||
got := strings.Builder { }
|
||||
file.WriteTo(&got)
|
||||
if got.String() != correct {
|
||||
test.Error("strings do not match")
|
||||
test.Errorf("EXPECTED:\n%s", correct)
|
||||
test.Errorf("GOT:\n%s", got.String())
|
||||
test.Fail()
|
||||
}
|
||||
}
|
||||
|
||||
func testValueString (test *testing.T, got Value, correct string) {
|
||||
if got.String() != correct {
|
||||
test.Error("strings do not match")
|
||||
test.Errorf("EXPECTED:\n%s", correct)
|
||||
test.Errorf("GOT:\n%s", got.String())
|
||||
test.Fail()
|
||||
}
|
||||
}
|
318
config/impl.go
@ -1,318 +0,0 @@
|
||||
package config
|
||||
|
||||
import "os"
|
||||
import "log"
|
||||
import "sync"
|
||||
import "slices"
|
||||
import "path/filepath"
|
||||
import "github.com/fsnotify/fsnotify"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
|
||||
// Goroutine model:
|
||||
// All private methods (except for lockAndProcessEvent) do not lock the config,
|
||||
// but all public methods do. Private methods may not call public methods.
|
||||
// Locking must always be method-level, with a call to Lock at the start,
|
||||
// directly followed by a deferred call to Unlock.
|
||||
|
||||
type config struct {
|
||||
open bool
|
||||
watcher *fsnotify.Watcher
|
||||
lock sync.RWMutex
|
||||
ignoreNextUserUpdate bool
|
||||
|
||||
paths struct {
|
||||
user string
|
||||
system []string
|
||||
watching map[string] struct { }
|
||||
}
|
||||
|
||||
data struct {
|
||||
user *File
|
||||
system []map[string] Value
|
||||
}
|
||||
|
||||
on struct {
|
||||
change event.Broadcaster[func (string)]
|
||||
}
|
||||
}
|
||||
|
||||
// NewConfig creates a new Config using paths to the user-level config file, and
|
||||
// a set of system config files. These files need not exist: the user-level file
|
||||
// will be created when Set is called for the first time if it does not exist
|
||||
// already, and nonexistent system files are simply ignored (unless the Config
|
||||
// finds them at any point to have been spontaneously created).
|
||||
//
|
||||
// The user file is written to when Set is called, and the system files are only
|
||||
// read from. Values in the user file override those in the system files, and
|
||||
// system files specified nearer to the start of the vararg list will override
|
||||
// those farther down.
|
||||
func NewConfig (user string, system ...string) (ConfigCloser, error) {
|
||||
conf := new(config)
|
||||
conf.paths.user = user
|
||||
conf.paths.system = system
|
||||
err := conf.init()
|
||||
if err != nil { return nil, err }
|
||||
go func () {
|
||||
for event := range conf.watcher.Events {
|
||||
conf.lockAndProcessEvent(event)
|
||||
}
|
||||
} ()
|
||||
return conf, nil
|
||||
}
|
||||
|
||||
// this method may only be run in the goroutine spawned by NewConfig.
|
||||
func (this *config) lockAndProcessEvent (event fsnotify.Event) {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
if !(event.Has(fsnotify.Write | fsnotify.Create)) { return }
|
||||
if _, ok := this.paths.watching[event.Name]; !ok { return }
|
||||
|
||||
if event.Name == this.paths.user {
|
||||
if !this.ignoreNextUserUpdate {
|
||||
previousUser := this.data.user
|
||||
this.reloadUser()
|
||||
newUser := this.data.user
|
||||
this.processUserDiff(newUser.Diff(previousUser))
|
||||
}
|
||||
this.ignoreNextUserUpdate = false
|
||||
} else {
|
||||
index := slices.Index(this.paths.system, event.Name)
|
||||
if index > 0 {
|
||||
previousSystem := this.data.system[index]
|
||||
this.reloadSystem(index)
|
||||
newSystem := this.data.system[index]
|
||||
this.processSystemDiff(index, diffValueMaps(newSystem, previousSystem))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (this *config) init () error {
|
||||
watcher, err := fsnotify.NewWatcher()
|
||||
if err != nil { return err }
|
||||
this.watcher = watcher
|
||||
|
||||
this.paths.watching = make(map[string] struct { })
|
||||
this.watcher.Add(filepath.Dir(this.paths.user))
|
||||
this.paths.watching[this.paths.user] = struct { } { }
|
||||
this.reloadUser()
|
||||
for index, path := range this.paths.system {
|
||||
this.watcher.Add(filepath.Dir(path))
|
||||
this.paths.watching[path] = struct { } { }
|
||||
this.reloadSystem(index)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *config) errIfClosed () error {
|
||||
if this.open {
|
||||
return nil
|
||||
} else {
|
||||
return ErrClosed
|
||||
}
|
||||
}
|
||||
|
||||
func (this *config) reloadUser () {
|
||||
file, err := os.Open(this.paths.user)
|
||||
if err != nil { return }
|
||||
defer file.Close()
|
||||
|
||||
userFile, err := Parse(file)
|
||||
if err != nil {
|
||||
log.Printf("nasin: problems loading user config file %s: %v", this.paths.user, err)
|
||||
return
|
||||
}
|
||||
this.data.user = userFile
|
||||
}
|
||||
|
||||
func (this *config) reloadSystem (index int) {
|
||||
path := this.paths.system[index]
|
||||
file, err := os.Open(path)
|
||||
if err != nil { return }
|
||||
defer file.Close()
|
||||
|
||||
systemFile, err := Parse(file)
|
||||
if err != nil {
|
||||
log.Printf("nasin: problems loading system config file %s: %v", path, err)
|
||||
return
|
||||
}
|
||||
this.data.system[index] = systemFile.Map()
|
||||
}
|
||||
|
||||
func (this *config) saveUser () error {
|
||||
// TODO set some sort of flag to ignore the next inotify event for the
|
||||
// user file so we dont reload it immediately after. also need to
|
||||
// broadacast Changed event.
|
||||
enclosingDir := filepath.Dir(this.paths.user)
|
||||
err := os.MkdirAll(enclosingDir, 755)
|
||||
if err != nil { return err }
|
||||
file, err := os.Create(this.paths.user)
|
||||
if err != nil { return err }
|
||||
defer file.Close()
|
||||
_, err = this.data.user.WriteTo(file)
|
||||
if err != nil { return err }
|
||||
this.ignoreNextUserUpdate = true
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *config) processUserDiff (changed map[string] struct { }) {
|
||||
for key := range changed {
|
||||
// this is the user file, and nothing has precedence over it, so
|
||||
// the change always matters
|
||||
this.broadcastChange(key)
|
||||
}
|
||||
}
|
||||
|
||||
func (this *config) processSystemDiff (index int, changed map[string] struct { }) {
|
||||
for key := range changed {
|
||||
// if specified in the user file, the change doesn't matter
|
||||
if this.data.user != nil {
|
||||
if has, _ := this.data.user.Has(key); has {
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
// if specified in any system files with precedence greater than
|
||||
// this one, the change doesn't matter
|
||||
for _, system := range this.data.system[:index] {
|
||||
if _, has := system[key]; has {
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
// the change does matter
|
||||
this.broadcastChange(key)
|
||||
}
|
||||
}
|
||||
|
||||
func (this *config) broadcastChange (key string) {
|
||||
for _, listener := range this.on.change.Listeners() {
|
||||
tomo.Do(func () { listener(key) })
|
||||
}
|
||||
}
|
||||
|
||||
func (this *config) get (key string, fallback Value) (Value, error) {
|
||||
// try user config
|
||||
if !KeyValid(key) { return nil, ErrMalformedKey }
|
||||
|
||||
if this.data.user != nil {
|
||||
value, err := this.data.user.Get(key)
|
||||
if err == nil && err != ErrNonexistentEntry {
|
||||
return value, nil
|
||||
}
|
||||
}
|
||||
|
||||
// try system configs
|
||||
for _, config := range this.data.system {
|
||||
if value, ok := config[key]; ok {
|
||||
return value, nil
|
||||
}
|
||||
}
|
||||
|
||||
// use fallback
|
||||
return fallback, nil
|
||||
|
||||
}
|
||||
|
||||
func (this *config) Get (key string, fallback Value) (Value, error) {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
return this.get(key, fallback)
|
||||
}
|
||||
|
||||
func (this *config) Close () error {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
this.open = false
|
||||
return this.watcher.Close()
|
||||
}
|
||||
|
||||
func (this *config) GetString (key string, fallback string) (string, error) {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
value, err := this.get(key, ValueString(fallback))
|
||||
if err != nil { return "", err }
|
||||
if value, ok := value.(ValueString); ok {
|
||||
return string(value), nil
|
||||
}
|
||||
return fallback, nil
|
||||
}
|
||||
|
||||
func (this *config) GetNumber (key string, fallback float64) (float64, error) {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
value, err := this.get(key, ValueNumber(fallback))
|
||||
if err != nil { return 0, err }
|
||||
if value, ok := value.(ValueNumber); ok {
|
||||
return float64(value), nil
|
||||
}
|
||||
return fallback, nil
|
||||
}
|
||||
|
||||
func (this *config) GetBool (key string, fallback bool) (bool, error) {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
value, err := this.get(key, ValueBool(fallback))
|
||||
if err != nil { return false, err }
|
||||
if value, ok := value.(ValueBool); ok {
|
||||
return bool(value), nil
|
||||
}
|
||||
return fallback, nil
|
||||
}
|
||||
|
||||
func (this *config) Set (key string, value Value) error {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
if this.data.user == nil { this.data.user = NewFile() }
|
||||
err := this.data.user.Set(key, value)
|
||||
if err != nil { return err }
|
||||
err = this.saveUser()
|
||||
if err != nil { return err }
|
||||
this.broadcastChange(key)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *config) Reset (key string) error {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
if this.data.user == nil { this.data.user = NewFile() }
|
||||
err := this.data.user.Reset(key)
|
||||
if err != nil { return err }
|
||||
err = this.saveUser()
|
||||
if err != nil { return err }
|
||||
this.broadcastChange(key)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *config) OnChange (callback func (string)) event.Cookie {
|
||||
this.lock.Lock()
|
||||
defer this.lock.Unlock()
|
||||
return this.on.change.Connect(callback)
|
||||
}
|
||||
|
||||
func diffValueMaps (first, second map[string] Value) map[string] struct { } {
|
||||
diff := make(map[string] struct { })
|
||||
|
||||
// - keys only first has
|
||||
// - keys both have, but are different
|
||||
for key, firstValue := range first {
|
||||
secondValue, ok := second[key]
|
||||
if !ok {
|
||||
diff[key] = struct { } { }
|
||||
continue
|
||||
}
|
||||
if !firstValue.Equals(secondValue) {
|
||||
diff[key] = struct { } { }
|
||||
}
|
||||
}
|
||||
|
||||
// - keys only second has
|
||||
for key := range second {
|
||||
if _, has := first[key]; !has {
|
||||
diff[key] = struct { } { }
|
||||
}
|
||||
}
|
||||
|
||||
return diff
|
||||
}
|
@ -1,53 +0,0 @@
|
||||
package config
|
||||
|
||||
import "maps"
|
||||
import "testing"
|
||||
|
||||
func TestDiffValueMapsNone (test *testing.T) {
|
||||
str := `
|
||||
thing = something
|
||||
|
||||
otherThing = otherValue
|
||||
# comment
|
||||
otherThing = true
|
||||
otherThing = 234
|
||||
|
||||
yetAnotherThing = 0.23498
|
||||
`
|
||||
file1 := parseFileString(test, str)
|
||||
file2 := parseFileString(test, str)
|
||||
diff := diffValueMaps(file1.Map(), file2.Map())
|
||||
if len(diff) != 0 {
|
||||
test.Fatalf("diff not empty:\n%v", diff)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiffValueMaps (test *testing.T) {
|
||||
file1 := parseFileString(test,
|
||||
`key4=0
|
||||
key1=value1
|
||||
# comment
|
||||
key2=34`)
|
||||
file2 := parseFileString(test,
|
||||
`key1=value2
|
||||
key2=34
|
||||
# comment
|
||||
|
||||
key3=0.2`)
|
||||
diff := diffValueMaps(file1.Map(), file2.Map())
|
||||
correct := map[string] struct { } {
|
||||
"key1": struct { } { },
|
||||
"key3": struct { } { },
|
||||
"key4": struct { } { },
|
||||
}
|
||||
if !maps.Equal(diff, correct) {
|
||||
test.Error("diffs do not match")
|
||||
test.Errorf("EXPECTED:\n%v", correct)
|
||||
test.Errorf("GOT:\n%v", diff)
|
||||
test.Fail()
|
||||
}
|
||||
}
|
||||
|
||||
// TODO we need way more tests!
|
||||
// need to test watching files. maybe make a temp dir and do it there. remember
|
||||
// to defer cleaning up the dir and closing of the config.
|
125
examples/clock/main.go
Normal file
@ -0,0 +1,125 @@
|
||||
// Example clock demonstrates the use of goroutines and tomo.Do() to provide
|
||||
// live-updating information.
|
||||
package main
|
||||
|
||||
import "time"
|
||||
import "math"
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/nasin"
|
||||
import "git.tebibyte.media/tomo/objects"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/objects/layouts"
|
||||
|
||||
type Application struct {
|
||||
clockFace *ClockFace
|
||||
timeLabel *objects.Label
|
||||
}
|
||||
|
||||
func (this *Application) Describe () nasin.ApplicationDescription {
|
||||
return nasin.ApplicationDescription {
|
||||
Name: "Clock",
|
||||
ID: "xyz.holanet.TomoClockExample",
|
||||
}
|
||||
}
|
||||
|
||||
func (this *Application) Init () error {
|
||||
window, err := nasin.NewApplicationWindow(this, image.Rect(0, 0, 128, 160))
|
||||
if err != nil { return err }
|
||||
|
||||
this.clockFace = NewClockFace()
|
||||
this.timeLabel = objects.NewLabel("")
|
||||
this.timeLabel.SetAlign(tomo.AlignMiddle, tomo.AlignMiddle)
|
||||
container := objects.NewOuterContainer (
|
||||
layouts.NewGrid([]bool { true }, []bool { true, false }),
|
||||
this.clockFace,
|
||||
this.timeLabel)
|
||||
window.SetRoot(container)
|
||||
|
||||
go func () {
|
||||
for {
|
||||
tomo.Do(this.updateTime)
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
} ()
|
||||
|
||||
window.OnClose(tomo.Stop)
|
||||
window.SetVisible(true)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *Application) updateTime () {
|
||||
now := time.Now()
|
||||
this.clockFace.SetTime(now)
|
||||
this.timeLabel.SetText(now.Format(time.DateTime))
|
||||
}
|
||||
|
||||
func main () {
|
||||
nasin.RunApplication(&Application { })
|
||||
}
|
||||
|
||||
type ClockFace struct {
|
||||
tomo.CanvasBox
|
||||
time time.Time
|
||||
}
|
||||
|
||||
func NewClockFace () *ClockFace {
|
||||
box := &ClockFace {
|
||||
CanvasBox: tomo.NewCanvasBox(),
|
||||
}
|
||||
tomo.Apply(box, tomo.R("nasin", "ClockFace", ""))
|
||||
box.SetDrawer(box)
|
||||
return box
|
||||
}
|
||||
|
||||
// TODO move ClockFace to objects
|
||||
|
||||
func (this *ClockFace) SetTime (when time.Time) {
|
||||
this.time = when
|
||||
this.Invalidate()
|
||||
}
|
||||
|
||||
func (this *ClockFace) Draw (destination canvas.Canvas) {
|
||||
pen := destination.Pen()
|
||||
pen.Fill(color.Transparent)
|
||||
pen.Rectangle(destination.Bounds())
|
||||
|
||||
for hour := 0; hour < 12; hour ++ {
|
||||
radialLine (
|
||||
destination,
|
||||
tomo.ColorForeground,
|
||||
0.8, 0.9, float64(hour) / 6 * math.Pi)
|
||||
}
|
||||
|
||||
second := float64(this.time.Second())
|
||||
minute := float64(this.time.Minute()) + second / 60
|
||||
hour := float64(this.time.Hour()) + minute / 60
|
||||
|
||||
radialLine(destination, tomo.ColorForeground, 0, 0.5, (hour - 3) / 6 * math.Pi)
|
||||
radialLine(destination, tomo.ColorForeground, 0, 0.7, (minute - 15) / 30 * math.Pi)
|
||||
radialLine(destination, tomo.ColorAccent, 0, 0.7, (second - 15) / 30 * math.Pi)
|
||||
}
|
||||
|
||||
func radialLine (
|
||||
destination canvas.Canvas,
|
||||
source color.Color,
|
||||
inner float64,
|
||||
outer float64,
|
||||
theta float64,
|
||||
) {
|
||||
pen := destination.Pen()
|
||||
bounds := destination.Bounds()
|
||||
width := float64(bounds.Dx()) / 2
|
||||
height := float64(bounds.Dy()) / 2
|
||||
min := bounds.Min.Add(image.Pt (
|
||||
int(math.Cos(theta) * inner * width + width),
|
||||
int(math.Sin(theta) * inner * height + height)))
|
||||
max := bounds.Min.Add(image.Pt (
|
||||
int(math.Cos(theta) * outer * width + width),
|
||||
int(math.Sin(theta) * outer * height + height)))
|
||||
|
||||
pen.Stroke(source)
|
||||
pen.StrokeWeight(1)
|
||||
pen.Path(min, max)
|
||||
}
|
423
examples/icons/main.go
Normal file
@ -0,0 +1,423 @@
|
||||
// Example icons demonstrates the use of icons, and buttons with icons.
|
||||
package main
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/nasin"
|
||||
import "git.tebibyte.media/tomo/objects"
|
||||
import "git.tebibyte.media/tomo/tomo/input"
|
||||
import "git.tebibyte.media/tomo/objects/layouts"
|
||||
import "git.tebibyte.media/tomo/nasin/internal/theme/xdgicons"
|
||||
|
||||
const scrollIcons = true
|
||||
|
||||
type Application struct {
|
||||
window tomo.MainWindow
|
||||
size tomo.IconSize
|
||||
grid tomo.ContainerBox
|
||||
}
|
||||
|
||||
func (this *Application) Describe () nasin.ApplicationDescription {
|
||||
return nasin.ApplicationDescription {
|
||||
Name: "Tomo Icon Example",
|
||||
ID: "xyz.holanet.TomoIconExample",
|
||||
}
|
||||
}
|
||||
|
||||
func (this *Application) Init () error {
|
||||
window, err := nasin.NewApplicationWindow(this, image.Rect(0, 0, 128, 256))
|
||||
if err != nil { return err }
|
||||
this.window = window
|
||||
|
||||
this.grid = objects.NewSunkenContainer(layouts.FlowVertical)
|
||||
this.resizeIcons(tomo.IconSizeSmall)
|
||||
|
||||
iconButtons := objects.NewInnerContainer(layouts.NewGrid([]bool { true, true, true}, []bool { false }))
|
||||
|
||||
button := objects.NewButton("small")
|
||||
button.SetIcon(tomo.IconZoomOut)
|
||||
button.OnClick(func () { this.resizeIcons(tomo.IconSizeSmall) })
|
||||
iconButtons.Add(button)
|
||||
|
||||
button = objects.NewButton("medium")
|
||||
button.SetIcon(tomo.IconZoomOriginal)
|
||||
button.OnClick(func () { this.resizeIcons(tomo.IconSizeMedium) })
|
||||
iconButtons.Add(button)
|
||||
|
||||
button = objects.NewButton("large")
|
||||
button.SetIcon(tomo.IconZoomIn)
|
||||
button.OnClick(func () { this.resizeIcons(tomo.IconSizeLarge) })
|
||||
iconButtons.Add(button)
|
||||
|
||||
container := objects.NewOuterContainer (
|
||||
layouts.NewGrid([]bool { true }, []bool { false, true, false }),
|
||||
objects.NewLabel("A smorgasbord of icons:"))
|
||||
if scrollIcons {
|
||||
iconScroller := objects.NewScrollContainer(objects.ScrollVertical)
|
||||
this.grid.SetOverflow(false, true)
|
||||
iconScroller.SetRoot(this.grid)
|
||||
container.Add(iconScroller)
|
||||
} else {
|
||||
container.Add(this.grid)
|
||||
}
|
||||
container.Add(iconButtons)
|
||||
window.SetRoot(container)
|
||||
|
||||
window.OnClose(tomo.Stop)
|
||||
window.SetVisible(true)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *Application) resizeIcons (size tomo.IconSize) {
|
||||
this.size = size
|
||||
this.grid.Clear()
|
||||
icons := []tomo.Icon {
|
||||
tomo.IconUnknown,
|
||||
tomo.IconAddressBookNew,
|
||||
tomo.IconApplicationExit,
|
||||
tomo.IconAppointmentNew,
|
||||
tomo.IconCallStart,
|
||||
tomo.IconCallStop,
|
||||
tomo.IconContactNew,
|
||||
tomo.IconDialogOkay,
|
||||
tomo.IconDialogCancel,
|
||||
tomo.IconEditClear,
|
||||
tomo.IconEditCopy,
|
||||
tomo.IconEditCut,
|
||||
tomo.IconEditDelete,
|
||||
tomo.IconEditFind,
|
||||
tomo.IconEditFindReplace,
|
||||
tomo.IconEditPaste,
|
||||
tomo.IconEditRedo,
|
||||
tomo.IconEditSelectAll,
|
||||
tomo.IconEditUndo,
|
||||
tomo.IconFileNew,
|
||||
tomo.IconDirectoryNew,
|
||||
tomo.IconFileOpen,
|
||||
tomo.IconFileOpenRecent,
|
||||
tomo.IconFilePageSetup,
|
||||
tomo.IconFilePrint,
|
||||
tomo.IconFilePrintPreview,
|
||||
tomo.IconFilePermissions,
|
||||
tomo.IconFileProperties,
|
||||
tomo.IconFileRename,
|
||||
tomo.IconFileRevert,
|
||||
tomo.IconFileSave,
|
||||
tomo.IconFileSaveAs,
|
||||
tomo.IconFileSend,
|
||||
tomo.IconFormatIndentLess,
|
||||
tomo.IconFormatIndentMore,
|
||||
tomo.IconFormatAlignCenter,
|
||||
tomo.IconFormatAlignEven,
|
||||
tomo.IconFormatAlignLeft,
|
||||
tomo.IconFormatAlignRight,
|
||||
tomo.IconFormatTextDirectionLtr,
|
||||
tomo.IconFormatTextDirectionRtl,
|
||||
tomo.IconFormatTextBold,
|
||||
tomo.IconFormatTextItalic,
|
||||
tomo.IconFormatTextUnderline,
|
||||
tomo.IconFormatTextStrikethrough,
|
||||
tomo.IconGoBottom,
|
||||
tomo.IconGoDown,
|
||||
tomo.IconGoFirst,
|
||||
tomo.IconGoHome,
|
||||
tomo.IconGoJump,
|
||||
tomo.IconGoLast,
|
||||
tomo.IconGoNext,
|
||||
tomo.IconGoPrevious,
|
||||
tomo.IconGoTop,
|
||||
tomo.IconGoUp,
|
||||
tomo.IconHelpAbout,
|
||||
tomo.IconHelpContents,
|
||||
tomo.IconHelpFaq,
|
||||
tomo.IconInsertImage,
|
||||
tomo.IconInsertLink,
|
||||
tomo.IconInsertObject,
|
||||
tomo.IconInsertText,
|
||||
tomo.IconListAdd,
|
||||
tomo.IconListRemove,
|
||||
tomo.IconMailForward,
|
||||
tomo.IconMailMarkImportant,
|
||||
tomo.IconMailMarkJunk,
|
||||
tomo.IconMailMarkNotJunk,
|
||||
tomo.IconMailMarkRead,
|
||||
tomo.IconMailMarkUnread,
|
||||
tomo.IconMailMessageNew,
|
||||
tomo.IconMailReplyAll,
|
||||
tomo.IconMailReplySender,
|
||||
tomo.IconMailSend,
|
||||
tomo.IconMailReceive,
|
||||
tomo.IconMediaEject,
|
||||
tomo.IconMediaPlaybackPause,
|
||||
tomo.IconMediaPlaybackStart,
|
||||
tomo.IconMediaPlaybackStop,
|
||||
tomo.IconMediaRecord,
|
||||
tomo.IconMediaSeekBackward,
|
||||
tomo.IconMediaSeekForward,
|
||||
tomo.IconMediaSkipBackward,
|
||||
tomo.IconMediaSkipForward,
|
||||
tomo.IconObjectFlipHorizontal,
|
||||
tomo.IconObjectFlipVertical,
|
||||
tomo.IconObjectRotateLeft,
|
||||
tomo.IconObjectRotateRight,
|
||||
tomo.IconProcessStop,
|
||||
tomo.IconSystemLockScreen,
|
||||
tomo.IconSystemLogOut,
|
||||
tomo.IconSystemRun,
|
||||
tomo.IconSystemSearch,
|
||||
tomo.IconSystemReboot,
|
||||
tomo.IconSystemShutdown,
|
||||
tomo.IconToolsCheckSpelling,
|
||||
tomo.IconValueIncrement,
|
||||
tomo.IconValueDecrement,
|
||||
tomo.IconValueReset,
|
||||
tomo.IconViewFullscreen,
|
||||
tomo.IconViewRefresh,
|
||||
tomo.IconViewRestore,
|
||||
tomo.IconViewSortAscending,
|
||||
tomo.IconViewSortDescending,
|
||||
tomo.IconWindowClose,
|
||||
tomo.IconWindowNew,
|
||||
tomo.IconZoomFitBest,
|
||||
tomo.IconZoomIn,
|
||||
tomo.IconZoomOriginal,
|
||||
tomo.IconZoomOut,
|
||||
tomo.IconApplication,
|
||||
tomo.IconApplicationWebBrowser,
|
||||
tomo.IconApplicationMesssanger,
|
||||
tomo.IconApplicationPhone,
|
||||
tomo.IconApplicationMail,
|
||||
tomo.IconApplicationTerminalEmulator,
|
||||
tomo.IconApplicationFileBrowser,
|
||||
tomo.IconApplicationTextEditor,
|
||||
tomo.IconApplicationDocumentViewer,
|
||||
tomo.IconApplicationWordProcessor,
|
||||
tomo.IconApplicationSpreadsheet,
|
||||
tomo.IconApplicationSlideshow,
|
||||
tomo.IconApplicationCalculator,
|
||||
tomo.IconApplicationPreferences,
|
||||
tomo.IconApplicationProcessManager,
|
||||
tomo.IconApplicationSystemInformation,
|
||||
tomo.IconApplicationManual,
|
||||
tomo.IconApplicationCamera,
|
||||
tomo.IconApplicationImageViewer,
|
||||
tomo.IconApplicationMediaPlayer,
|
||||
tomo.IconApplicationImageEditor,
|
||||
tomo.IconApplicationAudioEditor,
|
||||
tomo.IconApplicationVideoEditor,
|
||||
tomo.IconApplicationClock,
|
||||
tomo.IconApplicationCalendar,
|
||||
tomo.IconApplicationChecklist,
|
||||
tomo.IconApplications,
|
||||
tomo.IconApplicationsAccessories,
|
||||
tomo.IconApplicationsDevelopment,
|
||||
tomo.IconApplicationsEngineering,
|
||||
tomo.IconApplicationsGames,
|
||||
tomo.IconApplicationsGraphics,
|
||||
tomo.IconApplicationsInternet,
|
||||
tomo.IconApplicationsMultimedia,
|
||||
tomo.IconApplicationsOffice,
|
||||
tomo.IconApplicationsScience,
|
||||
tomo.IconApplicationsSystem,
|
||||
tomo.IconApplicationsUtilities,
|
||||
tomo.IconPreferences,
|
||||
tomo.IconPreferencesDesktop,
|
||||
tomo.IconPreferencesPeripherals,
|
||||
tomo.IconPreferencesPersonal,
|
||||
tomo.IconPreferencesSystem,
|
||||
tomo.IconPreferencesNetwork,
|
||||
tomo.IconDevice,
|
||||
tomo.IconDeviceCamera,
|
||||
tomo.IconDeviceWebCamera,
|
||||
tomo.IconDeviceComputer,
|
||||
tomo.IconDevicePda,
|
||||
tomo.IconDevicePhone,
|
||||
tomo.IconDevicePrinter,
|
||||
tomo.IconDeviceScanner,
|
||||
tomo.IconDeviceMultimediaPlayer,
|
||||
tomo.IconDeviceVideoDisplay,
|
||||
tomo.IconDeviceAudioInput,
|
||||
tomo.IconDeviceAudioOutput,
|
||||
tomo.IconHardware,
|
||||
tomo.IconHardwareCPU,
|
||||
tomo.IconHardwareGPU,
|
||||
tomo.IconHardwareRAM,
|
||||
tomo.IconHardwareSoundCard,
|
||||
tomo.IconHardwareNetworkAdapter,
|
||||
tomo.IconPowerBattery,
|
||||
tomo.IconStorageHardDisk,
|
||||
tomo.IconStorageFloppyDisk,
|
||||
tomo.IconStorageSolidState,
|
||||
tomo.IconStorageOptical,
|
||||
tomo.IconStorageFlashStick,
|
||||
tomo.IconStorageFlashCard,
|
||||
tomo.IconStorageMagneticTape,
|
||||
tomo.IconInputGaming,
|
||||
tomo.IconInputKeyboard,
|
||||
tomo.IconInputMouse,
|
||||
tomo.IconInputTablet,
|
||||
tomo.IconNetworkWired,
|
||||
tomo.IconNetworkWireless,
|
||||
tomo.IconNetworkCellular,
|
||||
tomo.IconNetworkLocal,
|
||||
tomo.IconNetworkInternet,
|
||||
tomo.IconNetworkVPN,
|
||||
tomo.IconNetworkServer,
|
||||
tomo.IconNetworkWorkgroup,
|
||||
tomo.IconEmblemDefault,
|
||||
tomo.IconEmblemEncrypted,
|
||||
tomo.IconEmblemFavorite,
|
||||
tomo.IconEmblemImportant,
|
||||
tomo.IconEmblemReadOnly,
|
||||
tomo.IconEmblemShared,
|
||||
tomo.IconEmblemSymbolicLink,
|
||||
tomo.IconEmblemSynchronized,
|
||||
tomo.IconEmblemSystem,
|
||||
tomo.IconEmblemUnreadable,
|
||||
tomo.IconPlaceDirectory,
|
||||
tomo.IconPlaceRemote,
|
||||
tomo.IconPlaceHome,
|
||||
tomo.IconPlaceDownloads,
|
||||
tomo.IconPlaceDesktop,
|
||||
tomo.IconPlacePhotos,
|
||||
tomo.IconPlaceBooks,
|
||||
tomo.IconPlaceBookmarks,
|
||||
tomo.IconPlaceTrash,
|
||||
tomo.IconPlaceDocuments,
|
||||
tomo.IconPlaceRepositories,
|
||||
tomo.IconPlaceMusic,
|
||||
tomo.IconPlaceArchives,
|
||||
tomo.IconPlaceFonts,
|
||||
tomo.IconPlaceBinaries,
|
||||
tomo.IconPlaceVideos,
|
||||
tomo.IconPlace3DObjects,
|
||||
tomo.IconPlaceHistory,
|
||||
tomo.IconPlacePreferences,
|
||||
tomo.IconCheckboxChecked,
|
||||
tomo.IconCheckboxUnchecked,
|
||||
tomo.IconAppointmentMissed,
|
||||
tomo.IconAppointmentSoon,
|
||||
tomo.IconDialogError,
|
||||
tomo.IconDialogInformation,
|
||||
tomo.IconDialogPassword,
|
||||
tomo.IconDialogQuestion,
|
||||
tomo.IconDialogWarning,
|
||||
tomo.IconDirectoryDragAccept,
|
||||
tomo.IconDirectoryFull,
|
||||
tomo.IconDirectoryOpen,
|
||||
tomo.IconDirectoryVisiting,
|
||||
tomo.IconTrashFull,
|
||||
tomo.IconResourceLoading,
|
||||
tomo.IconResourceMissing,
|
||||
tomo.IconMailAttachment,
|
||||
tomo.IconMailUnread,
|
||||
tomo.IconMailReplied,
|
||||
tomo.IconMailSigned,
|
||||
tomo.IconMailSignedVerified,
|
||||
tomo.IconCellularSignal0,
|
||||
tomo.IconCellularSignal1,
|
||||
tomo.IconCellularSignal2,
|
||||
tomo.IconCellularSignal3,
|
||||
tomo.IconWirelessSignal0,
|
||||
tomo.IconWirelessSignal1,
|
||||
tomo.IconWirelessSignal2,
|
||||
tomo.IconWirelessSignal3,
|
||||
tomo.IconNetworkError,
|
||||
tomo.IconNetworkIdle,
|
||||
tomo.IconNetworkOffline,
|
||||
tomo.IconNetworkReceive,
|
||||
tomo.IconNetworkTransmit,
|
||||
tomo.IconNetworkTransmitReceive,
|
||||
tomo.IconPrintError,
|
||||
tomo.IconPrintPrinting,
|
||||
tomo.IconSecurityHigh,
|
||||
tomo.IconSecurityMedium,
|
||||
tomo.IconSecurityLow,
|
||||
tomo.IconSoftwareUpdateAvailable,
|
||||
tomo.IconSoftwareUpdateUrgent,
|
||||
tomo.IconSoftwareInstalling,
|
||||
tomo.IconSyncError,
|
||||
tomo.IconSyncSynchronizing,
|
||||
tomo.IconTaskDue,
|
||||
tomo.IconTaskPastDue,
|
||||
tomo.IconUserAvailable,
|
||||
tomo.IconUserAway,
|
||||
tomo.IconUserIdle,
|
||||
tomo.IconUserOffline,
|
||||
tomo.IconBattery0,
|
||||
tomo.IconBattery1,
|
||||
tomo.IconBattery2,
|
||||
tomo.IconBattery3,
|
||||
tomo.IconBrightness0,
|
||||
tomo.IconBrightness1,
|
||||
tomo.IconBrightness2,
|
||||
tomo.IconBrightness3,
|
||||
tomo.IconVolume0,
|
||||
tomo.IconVolume1,
|
||||
tomo.IconVolume2,
|
||||
tomo.IconVolume3,
|
||||
tomo.IconPlaylistRepeat,
|
||||
tomo.IconPlaylistShuffle,
|
||||
tomo.IconWeatherClear,
|
||||
tomo.IconWeatherClearNight,
|
||||
tomo.IconWeatherFewClouds,
|
||||
tomo.IconWeatherFewCloudsNight,
|
||||
tomo.IconWeatherFog,
|
||||
tomo.IconWeatherOvercast,
|
||||
tomo.IconWeatherSevereAlert,
|
||||
tomo.IconWeatherShowers,
|
||||
tomo.IconWeatherShowersScattered,
|
||||
tomo.IconWeatherSnow,
|
||||
tomo.IconWeatherStorm,
|
||||
}
|
||||
|
||||
for _, icon := range icons {
|
||||
iconObject := objects.NewIcon(icon, size)
|
||||
this.grid.Add(iconObject)
|
||||
icon := icon
|
||||
iconObject.OnMouseDown(func (button input.Button) {
|
||||
if button != input.ButtonLeft { return }
|
||||
this.iconPopup(icon)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func (this *Application) iconPopup (icon tomo.Icon) error {
|
||||
popup, err := this.window.NewModal(image.Rectangle { })
|
||||
if err != nil { return err }
|
||||
|
||||
if icon == "" {
|
||||
icon = "<UNKNOWN>"
|
||||
}
|
||||
|
||||
sizesRow := objects.NewSunkenContainer (
|
||||
layouts.ContractHorizontal,
|
||||
objects.NewIcon(icon, tomo.IconSizeSmall),
|
||||
objects.NewIcon(icon, tomo.IconSizeMedium),
|
||||
objects.NewIcon(icon, tomo.IconSizeLarge))
|
||||
sizesRow.SetAlign(tomo.AlignMiddle, tomo.AlignMiddle)
|
||||
|
||||
okButton := objects.NewButton("OK")
|
||||
okButton.SetFocused(true)
|
||||
okButton.OnClick(popup.Close)
|
||||
okButton.SetIcon(tomo.IconDialogOkay)
|
||||
controlRow := objects.NewInnerContainer (
|
||||
layouts.ContractHorizontal,
|
||||
okButton)
|
||||
controlRow.SetAlign(tomo.AlignEnd, tomo.AlignMiddle)
|
||||
|
||||
popup.SetRoot(objects.NewOuterContainer (
|
||||
layouts.NewGrid([]bool { true }, []bool { false, false, true, false }),
|
||||
objects.NewLabel("Icon ID: " + string(icon)),
|
||||
objects.NewLabel("XDG Name: " + xdgIcons.XdgIconName(icon)),
|
||||
sizesRow,
|
||||
controlRow,
|
||||
))
|
||||
popup.SetTitle(string(icon) + ": Properties")
|
||||
popup.SetVisible(true)
|
||||
return nil
|
||||
}
|
||||
|
||||
func main () {
|
||||
nasin.RunApplication(&Application { })
|
||||
}
|
37
examples/inputs/main.go
Normal file
@ -0,0 +1,37 @@
|
||||
// Example inputs demonstrates the use of various user input methods.
|
||||
package main
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/nasin"
|
||||
import "git.tebibyte.media/tomo/objects"
|
||||
import "git.tebibyte.media/tomo/objects/layouts"
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (this *Application) Describe () nasin.ApplicationDescription {
|
||||
return nasin.ApplicationDescription {
|
||||
Name: "Tomo Input Example",
|
||||
ID: "xyz.holanet.TomoInputExample",
|
||||
}
|
||||
}
|
||||
|
||||
func (this *Application) Init () error {
|
||||
window, err := nasin.NewApplicationWindow(this, image.Rect(0, 0, 128, 128))
|
||||
if err != nil { return err }
|
||||
|
||||
window.SetRoot(objects.NewOuterContainer(layouts.ContractVertical,
|
||||
objects.NewTextInput(""),
|
||||
objects.NewHorizontalSlider(0.5),
|
||||
objects.NewLabelCheckbox(false, "checkbox"),
|
||||
objects.NewNumberInput(5),
|
||||
))
|
||||
|
||||
window.OnClose(tomo.Stop)
|
||||
window.SetVisible(true)
|
||||
return nil
|
||||
}
|
||||
|
||||
func main () {
|
||||
nasin.RunApplication(&Application { })
|
||||
}
|
674
examples/license/LICENSE
Normal file
@ -0,0 +1,674 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The GNU General Public License is a free, copyleft license for
|
||||
software and other kinds of works.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
the GNU General Public License is intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains free
|
||||
software for all its users. We, the Free Software Foundation, use the
|
||||
GNU General Public License for most of our software; it applies also to
|
||||
any other work released this way by its authors. You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
them if you wish), that you receive source code or can get it if you
|
||||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to prevent others from denying you
|
||||
these rights or asking you to surrender the rights. Therefore, you have
|
||||
certain responsibilities if you distribute copies of the software, or if
|
||||
you modify it: responsibilities to respect the freedom of others.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must pass on to the recipients the same
|
||||
freedoms that you received. You must make sure that they, too, receive
|
||||
or can get the source code. And you must show them these terms so they
|
||||
know their rights.
|
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps:
|
||||
(1) assert copyright on the software, and (2) offer you this License
|
||||
giving you legal permission to copy, distribute and/or modify it.
|
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains
|
||||
that there is no warranty for this free software. For both users' and
|
||||
authors' sake, the GPL requires that modified versions be marked as
|
||||
changed, so that their problems will not be attributed erroneously to
|
||||
authors of previous versions.
|
||||
|
||||
Some devices are designed to deny users access to install or run
|
||||
modified versions of the software inside them, although the manufacturer
|
||||
can do so. This is fundamentally incompatible with the aim of
|
||||
protecting users' freedom to change the software. The systematic
|
||||
pattern of such abuse occurs in the area of products for individuals to
|
||||
use, which is precisely where it is most unacceptable. Therefore, we
|
||||
have designed this version of the GPL to prohibit the practice for those
|
||||
products. If such problems arise substantially in other domains, we
|
||||
stand ready to extend this provision to those domains in future versions
|
||||
of the GPL, as needed to protect the freedom of users.
|
||||
|
||||
Finally, every program is threatened constantly by software patents.
|
||||
States should not allow patents to restrict development and use of
|
||||
software on general-purpose computers, but in those that do, we wish to
|
||||
avoid the special danger that patents applied to a free program could
|
||||
make it effectively proprietary. To prevent this, the GPL assures that
|
||||
patents cannot be used to render the program non-free.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
TERMS AND CONDITIONS
|
||||
|
||||
0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU General Public License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
||||
works, such as semiconductor masks.
|
||||
|
||||
"The Program" refers to any copyrightable work licensed under this
|
||||
License. Each licensee is addressed as "you". "Licensees" and
|
||||
"recipients" may be individuals or organizations.
|
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work
|
||||
in a fashion requiring copyright permission, other than the making of an
|
||||
exact copy. The resulting work is called a "modified version" of the
|
||||
earlier work or a work "based on" the earlier work.
|
||||
|
||||
A "covered work" means either the unmodified Program or a work based
|
||||
on the Program.
|
||||
|
||||
To "propagate" a work means to do anything with it that, without
|
||||
permission, would make you directly or secondarily liable for
|
||||
infringement under applicable copyright law, except executing it on a
|
||||
computer or modifying a private copy. Propagation includes copying,
|
||||
distribution (with or without modification), making available to the
|
||||
public, and in some countries other activities as well.
|
||||
|
||||
To "convey" a work means any kind of propagation that enables other
|
||||
parties to make or receive copies. Mere interaction with a user through
|
||||
a computer network, with no transfer of a copy, is not conveying.
|
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices"
|
||||
to the extent that it includes a convenient and prominently visible
|
||||
feature that (1) displays an appropriate copyright notice, and (2)
|
||||
tells the user that there is no warranty for the work (except to the
|
||||
extent that warranties are provided), that licensees may convey the
|
||||
work under this License, and how to view a copy of this License. If
|
||||
the interface presents a list of user commands or options, such as a
|
||||
menu, a prominent item in the list meets this criterion.
|
||||
|
||||
1. Source Code.
|
||||
|
||||
The "source code" for a work means the preferred form of the work
|
||||
for making modifications to it. "Object code" means any non-source
|
||||
form of a work.
|
||||
|
||||
A "Standard Interface" means an interface that either is an official
|
||||
standard defined by a recognized standards body, or, in the case of
|
||||
interfaces specified for a particular programming language, one that
|
||||
is widely used among developers working in that language.
|
||||
|
||||
The "System Libraries" of an executable work include anything, other
|
||||
than the work as a whole, that (a) is included in the normal form of
|
||||
packaging a Major Component, but which is not part of that Major
|
||||
Component, and (b) serves only to enable use of the work with that
|
||||
Major Component, or to implement a Standard Interface for which an
|
||||
implementation is available to the public in source code form. A
|
||||
"Major Component", in this context, means a major essential component
|
||||
(kernel, window system, and so on) of the specific operating system
|
||||
(if any) on which the executable work runs, or a compiler used to
|
||||
produce the work, or an object code interpreter used to run it.
|
||||
|
||||
The "Corresponding Source" for a work in object code form means all
|
||||
the source code needed to generate, install, and (for an executable
|
||||
work) run the object code and to modify the work, including scripts to
|
||||
control those activities. However, it does not include the work's
|
||||
System Libraries, or general-purpose tools or generally available free
|
||||
programs which are used unmodified in performing those activities but
|
||||
which are not part of the work. For example, Corresponding Source
|
||||
includes interface definition files associated with source files for
|
||||
the work, and the source code for shared libraries and dynamically
|
||||
linked subprograms that the work is specifically designed to require,
|
||||
such as by intimate data communication or control flow between those
|
||||
subprograms and other parts of the work.
|
||||
|
||||
The Corresponding Source need not include anything that users
|
||||
can regenerate automatically from other parts of the Corresponding
|
||||
Source.
|
||||
|
||||
The Corresponding Source for a work in source code form is that
|
||||
same work.
|
||||
|
||||
2. Basic Permissions.
|
||||
|
||||
All rights granted under this License are granted for the term of
|
||||
copyright on the Program, and are irrevocable provided the stated
|
||||
conditions are met. This License explicitly affirms your unlimited
|
||||
permission to run the unmodified Program. The output from running a
|
||||
covered work is covered by this License only if the output, given its
|
||||
content, constitutes a covered work. This License acknowledges your
|
||||
rights of fair use or other equivalent, as provided by copyright law.
|
||||
|
||||
You may make, run and propagate covered works that you do not
|
||||
convey, without conditions so long as your license otherwise remains
|
||||
in force. You may convey covered works to others for the sole purpose
|
||||
of having them make modifications exclusively for you, or provide you
|
||||
with facilities for running those works, provided that you comply with
|
||||
the terms of this License in conveying all material for which you do
|
||||
not control copyright. Those thus making or running the covered works
|
||||
for you must do so exclusively on your behalf, under your direction
|
||||
and control, on terms that prohibit them from making any copies of
|
||||
your copyrighted material outside their relationship with you.
|
||||
|
||||
Conveying under any other circumstances is permitted solely under
|
||||
the conditions stated below. Sublicensing is not allowed; section 10
|
||||
makes it unnecessary.
|
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
|
||||
No covered work shall be deemed part of an effective technological
|
||||
measure under any applicable law fulfilling obligations under article
|
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
similar laws prohibiting or restricting circumvention of such
|
||||
measures.
|
||||
|
||||
When you convey a covered work, you waive any legal power to forbid
|
||||
circumvention of technological measures to the extent such circumvention
|
||||
is effected by exercising rights under this License with respect to
|
||||
the covered work, and you disclaim any intention to limit operation or
|
||||
modification of the work as a means of enforcing, against the work's
|
||||
users, your or third parties' legal rights to forbid circumvention of
|
||||
technological measures.
|
||||
|
||||
4. Conveying Verbatim Copies.
|
||||
|
||||
You may convey verbatim copies of the Program's source code as you
|
||||
receive it, in any medium, provided that you conspicuously and
|
||||
appropriately publish on each copy an appropriate copyright notice;
|
||||
keep intact all notices stating that this License and any
|
||||
non-permissive terms added in accord with section 7 apply to the code;
|
||||
keep intact all notices of the absence of any warranty; and give all
|
||||
recipients a copy of this License along with the Program.
|
||||
|
||||
You may charge any price or no price for each copy that you convey,
|
||||
and you may offer support or warranty protection for a fee.
|
||||
|
||||
5. Conveying Modified Source Versions.
|
||||
|
||||
You may convey a work based on the Program, or the modifications to
|
||||
produce it from the Program, in the form of source code under the
|
||||
terms of section 4, provided that you also meet all of these conditions:
|
||||
|
||||
a) The work must carry prominent notices stating that you modified
|
||||
it, and giving a relevant date.
|
||||
|
||||
b) The work must carry prominent notices stating that it is
|
||||
released under this License and any conditions added under section
|
||||
7. This requirement modifies the requirement in section 4 to
|
||||
"keep intact all notices".
|
||||
|
||||
c) You must license the entire work, as a whole, under this
|
||||
License to anyone who comes into possession of a copy. This
|
||||
License will therefore apply, along with any applicable section 7
|
||||
additional terms, to the whole of the work, and all its parts,
|
||||
regardless of how they are packaged. This License gives no
|
||||
permission to license the work in any other way, but it does not
|
||||
invalidate such permission if you have separately received it.
|
||||
|
||||
d) If the work has interactive user interfaces, each must display
|
||||
Appropriate Legal Notices; however, if the Program has interactive
|
||||
interfaces that do not display Appropriate Legal Notices, your
|
||||
work need not make them do so.
|
||||
|
||||
A compilation of a covered work with other separate and independent
|
||||
works, which are not by their nature extensions of the covered work,
|
||||
and which are not combined with it such as to form a larger program,
|
||||
in or on a volume of a storage or distribution medium, is called an
|
||||
"aggregate" if the compilation and its resulting copyright are not
|
||||
used to limit the access or legal rights of the compilation's users
|
||||
beyond what the individual works permit. Inclusion of a covered work
|
||||
in an aggregate does not cause this License to apply to the other
|
||||
parts of the aggregate.
|
||||
|
||||
6. Conveying Non-Source Forms.
|
||||
|
||||
You may convey a covered work in object code form under the terms
|
||||
of sections 4 and 5, provided that you also convey the
|
||||
machine-readable Corresponding Source under the terms of this License,
|
||||
in one of these ways:
|
||||
|
||||
a) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by the
|
||||
Corresponding Source fixed on a durable physical medium
|
||||
customarily used for software interchange.
|
||||
|
||||
b) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by a
|
||||
written offer, valid for at least three years and valid for as
|
||||
long as you offer spare parts or customer support for that product
|
||||
model, to give anyone who possesses the object code either (1) a
|
||||
copy of the Corresponding Source for all the software in the
|
||||
product that is covered by this License, on a durable physical
|
||||
medium customarily used for software interchange, for a price no
|
||||
more than your reasonable cost of physically performing this
|
||||
conveying of source, or (2) access to copy the
|
||||
Corresponding Source from a network server at no charge.
|
||||
|
||||
c) Convey individual copies of the object code with a copy of the
|
||||
written offer to provide the Corresponding Source. This
|
||||
alternative is allowed only occasionally and noncommercially, and
|
||||
only if you received the object code with such an offer, in accord
|
||||
with subsection 6b.
|
||||
|
||||
d) Convey the object code by offering access from a designated
|
||||
place (gratis or for a charge), and offer equivalent access to the
|
||||
Corresponding Source in the same way through the same place at no
|
||||
further charge. You need not require recipients to copy the
|
||||
Corresponding Source along with the object code. If the place to
|
||||
copy the object code is a network server, the Corresponding Source
|
||||
may be on a different server (operated by you or a third party)
|
||||
that supports equivalent copying facilities, provided you maintain
|
||||
clear directions next to the object code saying where to find the
|
||||
Corresponding Source. Regardless of what server hosts the
|
||||
Corresponding Source, you remain obligated to ensure that it is
|
||||
available for as long as needed to satisfy these requirements.
|
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided
|
||||
you inform other peers where the object code and Corresponding
|
||||
Source of the work are being offered to the general public at no
|
||||
charge under subsection 6d.
|
||||
|
||||
A separable portion of the object code, whose source code is excluded
|
||||
from the Corresponding Source as a System Library, need not be
|
||||
included in conveying the object code work.
|
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any
|
||||
tangible personal property which is normally used for personal, family,
|
||||
or household purposes, or (2) anything designed or sold for incorporation
|
||||
into a dwelling. In determining whether a product is a consumer product,
|
||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
product received by a particular user, "normally used" refers to a
|
||||
typical or common use of that class of product, regardless of the status
|
||||
of the particular user or of the way in which the particular user
|
||||
actually uses, or expects or is expected to use, the product. A product
|
||||
is a consumer product regardless of whether the product has substantial
|
||||
commercial, industrial or non-consumer uses, unless such uses represent
|
||||
the only significant mode of use of the product.
|
||||
|
||||
"Installation Information" for a User Product means any methods,
|
||||
procedures, authorization keys, or other information required to install
|
||||
and execute modified versions of a covered work in that User Product from
|
||||
a modified version of its Corresponding Source. The information must
|
||||
suffice to ensure that the continued functioning of the modified object
|
||||
code is in no case prevented or interfered with solely because
|
||||
modification has been made.
|
||||
|
||||
If you convey an object code work under this section in, or with, or
|
||||
specifically for use in, a User Product, and the conveying occurs as
|
||||
part of a transaction in which the right of possession and use of the
|
||||
User Product is transferred to the recipient in perpetuity or for a
|
||||
fixed term (regardless of how the transaction is characterized), the
|
||||
Corresponding Source conveyed under this section must be accompanied
|
||||
by the Installation Information. But this requirement does not apply
|
||||
if neither you nor any third party retains the ability to install
|
||||
modified object code on the User Product (for example, the work has
|
||||
been installed in ROM).
|
||||
|
||||
The requirement to provide Installation Information does not include a
|
||||
requirement to continue to provide support service, warranty, or updates
|
||||
for a work that has been modified or installed by the recipient, or for
|
||||
the User Product in which it has been modified or installed. Access to a
|
||||
network may be denied when the modification itself materially and
|
||||
adversely affects the operation of the network or violates the rules and
|
||||
protocols for communication across the network.
|
||||
|
||||
Corresponding Source conveyed, and Installation Information provided,
|
||||
in accord with this section must be in a format that is publicly
|
||||
documented (and with an implementation available to the public in
|
||||
source code form), and must require no special password or key for
|
||||
unpacking, reading or copying.
|
||||
|
||||
7. Additional Terms.
|
||||
|
||||
"Additional permissions" are terms that supplement the terms of this
|
||||
License by making exceptions from one or more of its conditions.
|
||||
Additional permissions that are applicable to the entire Program shall
|
||||
be treated as though they were included in this License, to the extent
|
||||
that they are valid under applicable law. If additional permissions
|
||||
apply only to part of the Program, that part may be used separately
|
||||
under those permissions, but the entire Program remains governed by
|
||||
this License without regard to the additional permissions.
|
||||
|
||||
When you convey a copy of a covered work, you may at your option
|
||||
remove any additional permissions from that copy, or from any part of
|
||||
it. (Additional permissions may be written to require their own
|
||||
removal in certain cases when you modify the work.) You may place
|
||||
additional permissions on material, added by you to a covered work,
|
||||
for which you have or can give appropriate copyright permission.
|
||||
|
||||
Notwithstanding any other provision of this License, for material you
|
||||
add to a covered work, you may (if authorized by the copyright holders of
|
||||
that material) supplement the terms of this License with terms:
|
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the
|
||||
terms of sections 15 and 16 of this License; or
|
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or
|
||||
author attributions in that material or in the Appropriate Legal
|
||||
Notices displayed by works containing it; or
|
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or
|
||||
requiring that modified versions of such material be marked in
|
||||
reasonable ways as different from the original version; or
|
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or
|
||||
authors of the material; or
|
||||
|
||||
e) Declining to grant rights under trademark law for use of some
|
||||
trade names, trademarks, or service marks; or
|
||||
|
||||
f) Requiring indemnification of licensors and authors of that
|
||||
material by anyone who conveys the material (or modified versions of
|
||||
it) with contractual assumptions of liability to the recipient, for
|
||||
any liability that these contractual assumptions directly impose on
|
||||
those licensors and authors.
|
||||
|
||||
All other non-permissive additional terms are considered "further
|
||||
restrictions" within the meaning of section 10. If the Program as you
|
||||
received it, or any part of it, contains a notice stating that it is
|
||||
governed by this License along with a term that is a further
|
||||
restriction, you may remove that term. If a license document contains
|
||||
a further restriction but permits relicensing or conveying under this
|
||||
License, you may add to a covered work material governed by the terms
|
||||
of that license document, provided that the further restriction does
|
||||
not survive such relicensing or conveying.
|
||||
|
||||
If you add terms to a covered work in accord with this section, you
|
||||
must place, in the relevant source files, a statement of the
|
||||
additional terms that apply to those files, or a notice indicating
|
||||
where to find the applicable terms.
|
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the
|
||||
form of a separately written license, or stated as exceptions;
|
||||
the above requirements apply either way.
|
||||
|
||||
8. Termination.
|
||||
|
||||
You may not propagate or modify a covered work except as expressly
|
||||
provided under this License. Any attempt otherwise to propagate or
|
||||
modify it is void, and will automatically terminate your rights under
|
||||
this License (including any patent licenses granted under the third
|
||||
paragraph of section 11).
|
||||
|
||||
However, if you cease all violation of this License, then your
|
||||
license from a particular copyright holder is reinstated (a)
|
||||
provisionally, unless and until the copyright holder explicitly and
|
||||
finally terminates your license, and (b) permanently, if the copyright
|
||||
holder fails to notify you of the violation by some reasonable means
|
||||
prior to 60 days after the cessation.
|
||||
|
||||
Moreover, your license from a particular copyright holder is
|
||||
reinstated permanently if the copyright holder notifies you of the
|
||||
violation by some reasonable means, this is the first time you have
|
||||
received notice of violation of this License (for any work) from that
|
||||
copyright holder, and you cure the violation prior to 30 days after
|
||||
your receipt of the notice.
|
||||
|
||||
Termination of your rights under this section does not terminate the
|
||||
licenses of parties who have received copies or rights from you under
|
||||
this License. If your rights have been terminated and not permanently
|
||||
reinstated, you do not qualify to receive new licenses for the same
|
||||
material under section 10.
|
||||
|
||||
9. Acceptance Not Required for Having Copies.
|
||||
|
||||
You are not required to accept this License in order to receive or
|
||||
run a copy of the Program. Ancillary propagation of a covered work
|
||||
occurring solely as a consequence of using peer-to-peer transmission
|
||||
to receive a copy likewise does not require acceptance. However,
|
||||
nothing other than this License grants you permission to propagate or
|
||||
modify any covered work. These actions infringe copyright if you do
|
||||
not accept this License. Therefore, by modifying or propagating a
|
||||
covered work, you indicate your acceptance of this License to do so.
|
||||
|
||||
10. Automatic Licensing of Downstream Recipients.
|
||||
|
||||
Each time you convey a covered work, the recipient automatically
|
||||
receives a license from the original licensors, to run, modify and
|
||||
propagate that work, subject to this License. You are not responsible
|
||||
for enforcing compliance by third parties with this License.
|
||||
|
||||
An "entity transaction" is a transaction transferring control of an
|
||||
organization, or substantially all assets of one, or subdividing an
|
||||
organization, or merging organizations. If propagation of a covered
|
||||
work results from an entity transaction, each party to that
|
||||
transaction who receives a copy of the work also receives whatever
|
||||
licenses to the work the party's predecessor in interest had or could
|
||||
give under the previous paragraph, plus a right to possession of the
|
||||
Corresponding Source of the work from the predecessor in interest, if
|
||||
the predecessor has it or can get it with reasonable efforts.
|
||||
|
||||
You may not impose any further restrictions on the exercise of the
|
||||
rights granted or affirmed under this License. For example, you may
|
||||
not impose a license fee, royalty, or other charge for exercise of
|
||||
rights granted under this License, and you may not initiate litigation
|
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
any patent claim is infringed by making, using, selling, offering for
|
||||
sale, or importing the Program or any portion of it.
|
||||
|
||||
11. Patents.
|
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this
|
||||
License of the Program or a work on which the Program is based. The
|
||||
work thus licensed is called the contributor's "contributor version".
|
||||
|
||||
A contributor's "essential patent claims" are all patent claims
|
||||
owned or controlled by the contributor, whether already acquired or
|
||||
hereafter acquired, that would be infringed by some manner, permitted
|
||||
by this License, of making, using, or selling its contributor version,
|
||||
but do not include claims that would be infringed only as a
|
||||
consequence of further modification of the contributor version. For
|
||||
purposes of this definition, "control" includes the right to grant
|
||||
patent sublicenses in a manner consistent with the requirements of
|
||||
this License.
|
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
patent license under the contributor's essential patent claims, to
|
||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
propagate the contents of its contributor version.
|
||||
|
||||
In the following three paragraphs, a "patent license" is any express
|
||||
agreement or commitment, however denominated, not to enforce a patent
|
||||
(such as an express permission to practice a patent or covenant not to
|
||||
sue for patent infringement). To "grant" such a patent license to a
|
||||
party means to make such an agreement or commitment not to enforce a
|
||||
patent against the party.
|
||||
|
||||
If you convey a covered work, knowingly relying on a patent license,
|
||||
and the Corresponding Source of the work is not available for anyone
|
||||
to copy, free of charge and under the terms of this License, through a
|
||||
publicly available network server or other readily accessible means,
|
||||
then you must either (1) cause the Corresponding Source to be so
|
||||
available, or (2) arrange to deprive yourself of the benefit of the
|
||||
patent license for this particular work, or (3) arrange, in a manner
|
||||
consistent with the requirements of this License, to extend the patent
|
||||
license to downstream recipients. "Knowingly relying" means you have
|
||||
actual knowledge that, but for the patent license, your conveying the
|
||||
covered work in a country, or your recipient's use of the covered work
|
||||
in a country, would infringe one or more identifiable patents in that
|
||||
country that you have reason to believe are valid.
|
||||
|
||||
If, pursuant to or in connection with a single transaction or
|
||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
covered work, and grant a patent license to some of the parties
|
||||
receiving the covered work authorizing them to use, propagate, modify
|
||||
or convey a specific copy of the covered work, then the patent license
|
||||
you grant is automatically extended to all recipients of the covered
|
||||
work and works based on it.
|
||||
|
||||
A patent license is "discriminatory" if it does not include within
|
||||
the scope of its coverage, prohibits the exercise of, or is
|
||||
conditioned on the non-exercise of one or more of the rights that are
|
||||
specifically granted under this License. You may not convey a covered
|
||||
work if you are a party to an arrangement with a third party that is
|
||||
in the business of distributing software, under which you make payment
|
||||
to the third party based on the extent of your activity of conveying
|
||||
the work, and under which the third party grants, to any of the
|
||||
parties who would receive the covered work from you, a discriminatory
|
||||
patent license (a) in connection with copies of the covered work
|
||||
conveyed by you (or copies made from those copies), or (b) primarily
|
||||
for and in connection with specific products or compilations that
|
||||
contain the covered work, unless you entered into that arrangement,
|
||||
or that patent license was granted, prior to 28 March 2007.
|
||||
|
||||
Nothing in this License shall be construed as excluding or limiting
|
||||
any implied license or other defenses to infringement that may
|
||||
otherwise be available to you under applicable patent law.
|
||||
|
||||
12. No Surrender of Others' Freedom.
|
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot convey a
|
||||
covered work so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you may
|
||||
not convey it at all. For example, if you agree to terms that obligate you
|
||||
to collect a royalty for further conveying from those to whom you convey
|
||||
the Program, the only way you could satisfy both those terms and this
|
||||
License would be to refrain entirely from conveying the Program.
|
||||
|
||||
13. Use with the GNU Affero General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU Affero General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the special requirements of the GNU Affero General Public License,
|
||||
section 13, concerning interaction through a network will apply to the
|
||||
combination as such.
|
||||
|
||||
14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of
|
||||
the GNU General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Program specifies that a certain numbered version of the GNU General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU General Public License, you may choose any version ever published
|
||||
by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future
|
||||
versions of the GNU General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
author or copyright holder as a result of your choosing to follow a
|
||||
later version.
|
||||
|
||||
15. Disclaimer of Warranty.
|
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. Limitation of Liability.
|
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGES.
|
||||
|
||||
17. Interpretation of Sections 15 and 16.
|
||||
|
||||
If the disclaimer of warranty and limitation of liability provided
|
||||
above cannot be given local legal effect according to their terms,
|
||||
reviewing courts shall apply local law that most closely approximates
|
||||
an absolute waiver of all civil liability in connection with the
|
||||
Program, unless a warranty or assumption of liability accompanies a
|
||||
copy of the Program in return for a fee.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
state the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, your program's commands
|
||||
might be different; for a GUI interface, you would use an "about box".
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU GPL, see
|
||||
<https://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your program
|
||||
into proprietary programs. If your program is a subroutine library, you
|
||||
may consider it more useful to permit linking proprietary applications with
|
||||
the library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License. But first, please read
|
||||
<https://www.gnu.org/licenses/why-not-lgpl.html>.
|
62
examples/license/main.go
Normal file
@ -0,0 +1,62 @@
|
||||
// Example license demonstrates the use of a TextView to display licensing
|
||||
// information.
|
||||
package main
|
||||
|
||||
import "image"
|
||||
import _ "embed"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/nasin"
|
||||
import "git.tebibyte.media/tomo/objects"
|
||||
import "git.tebibyte.media/tomo/objects/layouts"
|
||||
|
||||
//go:embed LICENSE
|
||||
var license []byte
|
||||
|
||||
type Application struct { }
|
||||
|
||||
func (this *Application) Describe () nasin.ApplicationDescription {
|
||||
return nasin.ApplicationDescription {
|
||||
Name: "Tomo License Example",
|
||||
ID: "xyz.holanet.TomoLicenseExample",
|
||||
}
|
||||
}
|
||||
|
||||
func (this *Application) Init () error {
|
||||
window, err := nasin.NewApplicationWindow(this, image.Rect(0, 0, 600, 600))
|
||||
if err != nil { return err }
|
||||
|
||||
checkbox := objects.NewLabelCheckbox(false, "I accept these terms")
|
||||
checkbox.SetFocused(true)
|
||||
|
||||
okButtok := objects.NewButton("OK")
|
||||
okButtok.SetIcon(tomo.IconDialogOkay)
|
||||
okButtok.OnClick(func () {
|
||||
if checkbox.Value() {
|
||||
window.Close()
|
||||
} else {
|
||||
dialog, _ := objects.NewDialogOk (
|
||||
objects.DialogInformation, window,
|
||||
"", "You must read and agree to the license terms", nil)
|
||||
dialog.SetVisible(true)
|
||||
}
|
||||
})
|
||||
|
||||
scroller := objects.NewScrollContainer(objects.ScrollVertical)
|
||||
scroller.SetRoot(objects.NewTextView(string(license)))
|
||||
|
||||
window.SetRoot(objects.NewOuterContainer (
|
||||
layouts.NewGrid([]bool { true }, []bool { true, false }),
|
||||
scroller,
|
||||
objects.NewInnerContainer (
|
||||
layouts.NewGrid([]bool { true, false }, []bool { true }),
|
||||
checkbox,
|
||||
okButtok)))
|
||||
|
||||
window.OnClose(tomo.Stop)
|
||||
window.SetVisible(true)
|
||||
return nil
|
||||
}
|
||||
|
||||
func main () {
|
||||
nasin.RunApplication(&Application { })
|
||||
}
|
18
go.mod
@ -1,24 +1,20 @@
|
||||
module git.tebibyte.media/tomo/nasin
|
||||
|
||||
go 1.22.2
|
||||
go 1.20
|
||||
|
||||
require (
|
||||
git.tebibyte.media/sashakoshka/goparse v0.2.0
|
||||
git.tebibyte.media/tomo/backend v0.8.0
|
||||
git.tebibyte.media/tomo/objects v0.24.0
|
||||
git.tebibyte.media/tomo/tomo v0.48.0
|
||||
git.tebibyte.media/tomo/objects v0.15.0
|
||||
git.tebibyte.media/tomo/tomo v0.34.0
|
||||
git.tebibyte.media/tomo/x v0.9.0
|
||||
git.tebibyte.media/tomo/xdg v0.1.0
|
||||
github.com/fsnotify/fsnotify v1.7.0
|
||||
golang.org/x/image v0.11.0
|
||||
)
|
||||
|
||||
require (
|
||||
git.tebibyte.media/sashakoshka/goutil v0.3.1 // indirect
|
||||
git.tebibyte.media/tomo/typeset v0.8.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.1 // indirect
|
||||
github.com/jezek/xgbutil v0.0.0-20231116234834-47f30c120111 // indirect
|
||||
golang.org/x/sys v0.5.0 // indirect
|
||||
github.com/jezek/xgb v1.1.0 // indirect
|
||||
github.com/jezek/xgbutil v0.0.0-20230603163917-04188eb39cf0 // indirect
|
||||
)
|
||||
|
29
go.sum
@ -1,16 +1,12 @@
|
||||
git.tebibyte.media/sashakoshka/goparse v0.2.0 h1:uQmKvOCV2AOlCHEDjg9uclZCXQZzq2PxaXfZ1aIMiQI=
|
||||
git.tebibyte.media/sashakoshka/goparse v0.2.0/go.mod h1:tSQwfuD+EujRoKr6Y1oaRy74ZynatzkRLxjE3sbpCmk=
|
||||
git.tebibyte.media/sashakoshka/goutil v0.3.1 h1:zvAMKS+aea96q6oTttCWfNLXqOHisI3IKAwX6BWKfY0=
|
||||
git.tebibyte.media/sashakoshka/goutil v0.3.1/go.mod h1:Yo/M2sbi9IbzZCFsEj8/Fg7sNwHkDaJ6saTHOha+Dow=
|
||||
git.tebibyte.media/sashakoshka/xgbkb v1.0.0/go.mod h1:pNcE6TRO93vHd6q42SdwLSTTj25L0Yzggz7yLe0JV6Q=
|
||||
git.tebibyte.media/tomo/backend v0.8.0 h1:mPP6g60lL7v9GOjyUl/oGkHK/CV4ZJB8OUlw0E7WEhk=
|
||||
git.tebibyte.media/tomo/backend v0.8.0/go.mod h1:yIWW8XXDsaHfIhAuxg336oYlgX0uCn3lwgaydh8BagE=
|
||||
git.tebibyte.media/tomo/objects v0.24.0 h1:O91CxHJ1eA5/WJzDNm46lTA3Lm6t1CrLtf8gLKtuX7U=
|
||||
git.tebibyte.media/tomo/objects v0.24.0/go.mod h1:atTxG2mRqDQBFS/0KoqP9VR50BozFLi7XRz/AkFJtMo=
|
||||
git.tebibyte.media/tomo/tomo v0.48.0 h1:AE21ElHwUSPsX82ZWCnoNxJFi9Oswyd3dPDPMbxTueQ=
|
||||
git.tebibyte.media/tomo/tomo v0.48.0/go.mod h1:WrtilgKB1y8O2Yu7X4mYcRiqOlPR8NuUnoA/ynkQWrs=
|
||||
git.tebibyte.media/tomo/typeset v0.8.0 h1:4qA6oW4/3oPHj6/Zrp+JFJ53OmFSDvxs+J6BhO3DW00=
|
||||
git.tebibyte.media/tomo/typeset v0.8.0/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
|
||||
git.tebibyte.media/tomo/objects v0.15.0 h1:xCrRqOwCz8jDJk/sWw0B1HyrRCJafAuaPWN9nZj8V1U=
|
||||
git.tebibyte.media/tomo/objects v0.15.0/go.mod h1:++pM0y/xuzhgmu1RpHTWQlqrmyHLfPEF9ahyrH8Tqvk=
|
||||
git.tebibyte.media/tomo/tomo v0.34.0 h1:r5yJPks9rtzdDI2RyAUdqa1qb6BebG0QFe2cTmcFi+0=
|
||||
git.tebibyte.media/tomo/tomo v0.34.0/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/x v0.9.0 h1:wMcbK0MOE7ea7wcU2Mgrr86ZprVGLRY2PgOG0vDJR6Y=
|
||||
git.tebibyte.media/tomo/x v0.9.0/go.mod h1:OO4PYXhzrh4ZAY12d7bg+l/P4MbkFPu6f+YVXNDRhog=
|
||||
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=
|
||||
@ -19,14 +15,10 @@ github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298 h1:1qlsVAQJ
|
||||
github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298/go.mod h1:D+QujdIlUNfa0igpNMk6UIvlb6C252URs4yupRUV4lQ=
|
||||
github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966 h1:lTG4HQym5oPKjL7nGs+csTgiDna685ZXjxijkne828g=
|
||||
github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966/go.mod h1:Mid70uvE93zn9wgF92A/r5ixgnvX8Lh68fxp9KQBaI0=
|
||||
github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
|
||||
github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
|
||||
github.com/jezek/xgb v1.1.0 h1:wnpxJzP1+rkbGclEkmwpVFQWpuE2PUGNUzP8SbfFobk=
|
||||
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=
|
||||
github.com/jezek/xgbutil v0.0.0-20230603163917-04188eb39cf0 h1:Pf/0BAbppEOq4azPH6fnvUX2dycAwZdGkdxFn25j44c=
|
||||
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=
|
||||
@ -46,7 +38,6 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
|
||||
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
|
||||
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
|
||||
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
|
||||
|
@ -1,35 +0,0 @@
|
||||
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
|
||||
}
|
||||
}
|
@ -1,7 +0,0 @@
|
||||
# assets
|
||||
These are the assets for the fallback (Wintergreen) icon set. When making edits
|
||||
to these icons, open both the png and xcf files. When you wish to save your
|
||||
changes, delete the contents of the png file and paste in the "Icons" layer of
|
||||
the xcf file, then export the png file and save the xcf file. This is because
|
||||
the exported pngs use indexed color to save space as they are embedded into
|
||||
application binaries.
|
Before Width: | Height: | Size: 17 KiB |
Before Width: | Height: | Size: 6.5 KiB |
@ -1,82 +1,27 @@
|
||||
//go:build unix && (!darwin)
|
||||
package registrar
|
||||
|
||||
import "os"
|
||||
import "log"
|
||||
import "git.tebibyte.media/tomo/x"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/backend/x"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
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"
|
||||
import "git.tebibyte.media/tomo/nasin/internal/theme/default"
|
||||
import "git.tebibyte.media/tomo/nasin/internal/theme/xdgicons"
|
||||
|
||||
type Registrar struct {
|
||||
backend *x.Backend
|
||||
iconSetCookie event.Cookie
|
||||
styleCookie event.Cookie
|
||||
}
|
||||
func Init () error {
|
||||
theme := defaultTheme.Theme()
|
||||
|
||||
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) SetStyle (name string) error {
|
||||
if this.styleCookie != nil {
|
||||
this.styleCookie.Close()
|
||||
this.styleCookie = nil
|
||||
}
|
||||
|
||||
if name != "" {
|
||||
styl, cookie, err := tss.LoadFile(name)
|
||||
iconThemeName := os.Getenv("TOMO_XDG_ICON_THEME")
|
||||
if iconThemeName != "" {
|
||||
iconTheme, err := xdgIcons.FindThemeWarn(iconThemeName, theme.IconTheme)
|
||||
if err == nil {
|
||||
this.backend.SetStyle(styl)
|
||||
this.styleCookie = cookie
|
||||
return nil
|
||||
theme.IconTheme = iconTheme
|
||||
} else {
|
||||
log.Printf (
|
||||
"nasin: could not load style sheet '%s'\n%v",
|
||||
name, parse.Format(err))
|
||||
log.Printf("nasin: could not load icon theme '%s': %v", iconThemeName, err)
|
||||
}
|
||||
}
|
||||
|
||||
styl, cookie := fallbackStyle.New()
|
||||
this.styleCookie = cookie
|
||||
this.backend.SetStyle(styl)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *Registrar) SetIconSet (name string) error {
|
||||
if this.iconSetCookie != nil {
|
||||
this.iconSetCookie.Close()
|
||||
this.iconSetCookie = nil
|
||||
}
|
||||
|
||||
iconSet, cookie := fallbackIcons.New()
|
||||
if name != "" {
|
||||
xdgIconSet, xdgCookie, err := xdgIcons.FindThemeWarn(name, iconSet)
|
||||
cookie = event.MultiCookie(cookie, xdgCookie)
|
||||
if err == nil {
|
||||
iconSet = xdgIconSet
|
||||
} else {
|
||||
log.Printf("nasin: could not load icon theme '%s': %v", name, err)
|
||||
}
|
||||
}
|
||||
|
||||
this.backend.SetIconSet(iconSet)
|
||||
this.iconSetCookie = cookie
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *Registrar) SetFaceSet () error {
|
||||
// TODO replace this with something that uses findfont, and caches and
|
||||
// refcounts the faces
|
||||
faceSet := fallbackFaces.New()
|
||||
this.backend.SetFaceSet(faceSet)
|
||||
tomo.SetTheme(theme)
|
||||
tomo.Register(1, x.NewBackend)
|
||||
return nil
|
||||
}
|
||||
|
@ -1,331 +0,0 @@
|
||||
// Colors
|
||||
$ColorDot = #7391c080;
|
||||
$ColorAccent = #5f8bc4;
|
||||
$ColorHighlight = #5f8bc4;
|
||||
$ColorBackground = #d4d4d4;
|
||||
$ColorForeground = #000;
|
||||
$ColorOutline = $ColorForeground;
|
||||
$ColorGutter = #bfc6d1;
|
||||
$ColorGutterHovered = #c5cbd6;
|
||||
$ColorRaised = #e9eaea;
|
||||
$ColorRaisedPressed = #ccd4dd;
|
||||
$ColorRaisedFocused = #cfd6dd;
|
||||
$ColorRaisedHovered = #f1f3f5;
|
||||
$ColorSunken = #e9eaea;
|
||||
$ColorSunkenFocused = #e0e6ee;
|
||||
$ColorSunkenPressed = #e0e6ee;
|
||||
$ColorCalendarWeekdayHeader = #d3cac2;
|
||||
$ColorCalendarWeekend = #c2d3c4;
|
||||
$ColorCalendarDay = #d6dae2;
|
||||
$ColorOptionSegment = #c6c8cc;
|
||||
|
||||
// Borders
|
||||
$BorderOutline = $ColorOutline ;
|
||||
$BorderEngraved = #c3c3c5 #e3e3e3 #e9e9e9 #c2c2c2;
|
||||
$BorderGap = #697c7c #566767 #566767 #697c7c;
|
||||
$BorderLifted = #f9fafc #c2c8d3 #a4afc0 #f5f6f8;
|
||||
$BorderLiftedFocused = #f0f4f9 #b1baca #9aa6b7 #e4e9ee;
|
||||
$BorderFocused = #5f8bc4 #5f8bc4 #5f8bc4 #5f8bc4;
|
||||
$BorderTear = $BorderEngraved ;
|
||||
$BorderTearFocused = #7f94b5 #ced7e4 #ced7e4 #7f94b5;
|
||||
$BorderTearPad = #0000 ;
|
||||
$BorderTearPadFocused = #7391c080 ;
|
||||
$BorderInnerShadow = #a4afc0 ;
|
||||
$BorderOuterShadow = #a4afc0 ;
|
||||
$BorderOptionSegment = #b0b6c0 ;
|
||||
|
||||
*.* {
|
||||
TextColor: $ColorForeground;
|
||||
DotColor: $ColorDot;
|
||||
Gap: 8;
|
||||
}
|
||||
|
||||
*.Button {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderLifted / 1;
|
||||
Padding: 4 8;
|
||||
Color: $ColorRaised;
|
||||
}
|
||||
|
||||
*.Button[focused] {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderLiftedFocused / 1;
|
||||
Padding: 4 8;
|
||||
Color: $ColorRaisedFocused;
|
||||
}
|
||||
|
||||
*.Button[hovered] {
|
||||
Color: $ColorRaisedHovered;
|
||||
}
|
||||
|
||||
*.Button[pressed] {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Padding: 5 8 4 9;
|
||||
Color: $ColorRaisedPressed;
|
||||
}
|
||||
|
||||
*.TextInput {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Padding: 5 4 4 5;
|
||||
Color: $ColorSunken;
|
||||
}
|
||||
|
||||
*.TextInput[focused] {
|
||||
Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
}
|
||||
|
||||
*.TextView {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Padding: 5 4 4 5;
|
||||
Color: $ColorSunken;
|
||||
}
|
||||
|
||||
*.NumberInput {
|
||||
Gap: 0;
|
||||
}
|
||||
|
||||
*.Heading {
|
||||
Align: middle middle;
|
||||
}
|
||||
|
||||
*.Heading[menu] {
|
||||
Align: middle middle;
|
||||
Padding: 4 8;
|
||||
}
|
||||
|
||||
*.Pegboard {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Padding: 5 4 4 5;
|
||||
Color: $ColorSunken;
|
||||
}
|
||||
|
||||
*.Segment {
|
||||
Padding: 8;
|
||||
}
|
||||
|
||||
*.Segment[command] {
|
||||
Padding: 8 8 0 8;
|
||||
}
|
||||
|
||||
*.Segment[status] {
|
||||
Color: $ColorOptionSegment;
|
||||
Border: $BorderOptionSegment / 1 0 0 0;
|
||||
}
|
||||
|
||||
*.Segment[option] {
|
||||
Color: $ColorOptionSegment;
|
||||
Border: $BorderOptionSegment / 1 0 0 0;
|
||||
}
|
||||
|
||||
*.Separator {
|
||||
Border: $BorderEngraved / 1;
|
||||
}
|
||||
|
||||
*.Slider {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Color: $ColorGutter;
|
||||
}
|
||||
|
||||
*.Slider[focused] {
|
||||
Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
}
|
||||
|
||||
*.Slider[hovered] {
|
||||
Color: $ColorGutterHovered;
|
||||
}
|
||||
|
||||
*.Slider[horizontal] {
|
||||
MinimumSize: 48 0;
|
||||
}
|
||||
|
||||
*.Slider[vertical] {
|
||||
MinimumSize: 0 48;
|
||||
}
|
||||
|
||||
*.SliderHandle {
|
||||
Border: $BorderOuterShadow / 0 1 1 0, $BorderGap / 1, $BorderLifted / 1;
|
||||
Color: $ColorRaised;
|
||||
MinimumSize: 12;
|
||||
}
|
||||
|
||||
*.Scrollbar {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Color: $ColorGutter;
|
||||
}
|
||||
|
||||
*.Scrollbar[focused] {
|
||||
Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
}
|
||||
|
||||
*.Scrollbar[hovered] {
|
||||
Color: $ColorGutterHovered;
|
||||
}
|
||||
|
||||
*.Scrollbar[horizontal] {
|
||||
MinimumSize: 48 0;
|
||||
}
|
||||
|
||||
*.Scrollbar[vertical] {
|
||||
MinimumSize: 0 48;
|
||||
}
|
||||
|
||||
*.ScrollbarHandle {
|
||||
Border: $BorderOuterShadow / 0 1 1 0, $BorderGap / 1, $BorderLifted / 1;
|
||||
Color: $ColorRaised;
|
||||
MinimumSize: 12;
|
||||
}
|
||||
|
||||
*.ScrollContainer {
|
||||
Gap: 0;
|
||||
}
|
||||
|
||||
*.Checkbox {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Color: $ColorSunken;
|
||||
Padding: 0 1 1 0;
|
||||
MinimumSize: 19;
|
||||
}
|
||||
|
||||
*.Checkbox[focused] {
|
||||
Border: $BorderEngraved / 1, $BorderFocused / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Color: $ColorSunkenFocused;
|
||||
Padding: 0;
|
||||
}
|
||||
|
||||
*.Checkbox[checked] {
|
||||
Texture: "assets/checkbox-checked.png";
|
||||
TextureMode: center;
|
||||
}
|
||||
|
||||
*.MenuItem {
|
||||
Padding: 4;
|
||||
Gap: 4;
|
||||
Color: #0000;
|
||||
}
|
||||
|
||||
*.MenuItem[focused] {
|
||||
Color: $ColorDot;
|
||||
}
|
||||
|
||||
*.File {
|
||||
Color: #0000;
|
||||
}
|
||||
|
||||
*.File[focused] {
|
||||
Color: $ColorDot;
|
||||
}
|
||||
|
||||
*.TearLine {
|
||||
Border: $BorderTearPad / 3, $BorderTear / 1;
|
||||
}
|
||||
|
||||
*.TearLine[focused] {
|
||||
Border: $BorderTearPadFocused / 3, $BorderTearFocused / 1;
|
||||
}
|
||||
|
||||
*.Calendar {
|
||||
Border: $BorderOuterShadow / 0 1 1 0, $BorderGap / 1;
|
||||
Color: $ColorRaised;
|
||||
Padding: 2;
|
||||
Gap: 2;
|
||||
}
|
||||
|
||||
*.CalendarGrid {
|
||||
Gap: 2 2;
|
||||
}
|
||||
|
||||
*.CalendarWeekdayHeader {
|
||||
Color: $ColorCalendarWeekdayHeader;
|
||||
Padding: 2;
|
||||
}
|
||||
|
||||
*.CalendarDay {
|
||||
Color: $ColorCalendarDay;
|
||||
Padding: 2;
|
||||
MinimumSize: 32;
|
||||
}
|
||||
|
||||
*.CalendarDay[weekend] {
|
||||
Color: $ColorCalendarWeekend;
|
||||
}
|
||||
|
||||
*.Root {
|
||||
Color: $ColorBackground;
|
||||
Gap: 0;
|
||||
}
|
||||
|
||||
*.Root[menu] {
|
||||
Border: $BorderGap / 1, $BorderLifted / 1;
|
||||
Color: $ColorBackground;
|
||||
Gap: 0;
|
||||
}
|
||||
|
||||
*.Root[menu, torn] {
|
||||
Border: ;
|
||||
Color: $ColorBackground;
|
||||
Gap: 0;
|
||||
}
|
||||
|
||||
*.TabbedContainer {
|
||||
Gap: 0;
|
||||
}
|
||||
|
||||
*.TabRow {
|
||||
Border: $BorderEngraved / 1 1 0 1, $BorderGap / 1 1 0 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Color: $ColorSunken;
|
||||
Gap: 0;
|
||||
Padding: 1 0 0 0;
|
||||
}
|
||||
|
||||
*.Tab {
|
||||
Border: #0000 / 1 0 0 0, $BorderOuterShadow / 0 1 0 0, $BorderGap / 1 1 0 1, $BorderLifted / 1;
|
||||
Color: $ColorSunken;
|
||||
Padding: 4 8 2 8;
|
||||
}
|
||||
|
||||
*.Tab[active] {
|
||||
Border: $BorderOuterShadow / 0 1 0 0, $BorderGap / 1 1 0 1, $BorderLifted / 1 1 0 1;
|
||||
Color: $ColorBackground;
|
||||
Padding: 4 8;
|
||||
}
|
||||
|
||||
*.TabSpacer {
|
||||
Border: $BorderLifted / 0 0 1 0;
|
||||
MinimumSize: 1 0;
|
||||
}
|
||||
|
||||
*.Swatch {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1;
|
||||
Color: #FFF;
|
||||
MinimumSize: 19;
|
||||
}
|
||||
|
||||
*.Swatch[focused] {
|
||||
Border: $BorderEngraved / 1, $BorderFocused / 1;
|
||||
}
|
||||
|
||||
*.ColorPickerMap {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1;
|
||||
Color: $ColorSunken;
|
||||
MinimumSize: 128;
|
||||
}
|
||||
|
||||
*.Dropdown {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderLifted / 1;
|
||||
Padding: 4 8;
|
||||
Color: $ColorRaised;
|
||||
}
|
||||
|
||||
*.Dropdown[focused] {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderLiftedFocused / 1;
|
||||
Padding: 4 8;
|
||||
Color: $ColorRaisedFocused;
|
||||
}
|
||||
|
||||
*.Dropdown[hovered] {
|
||||
Color: $ColorRaisedHovered;
|
||||
}
|
||||
|
||||
*.Dropdown[pressed] {
|
||||
Border: $BorderEngraved / 1, $BorderGap / 1, $BorderInnerShadow / 1 0 0 1;
|
||||
Padding: 5 8 4 9;
|
||||
Color: $ColorRaisedPressed;
|
||||
}
|
Before Width: | Height: | Size: 105 B |
Before Width: | Height: | Size: 409 B |
@ -1,632 +0,0 @@
|
||||
package fallbackStyle
|
||||
|
||||
import "bytes"
|
||||
import "image"
|
||||
import _ "embed"
|
||||
import _ "image/png"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
import "git.tebibyte.media/tomo/backend/style"
|
||||
|
||||
// Note: these are color.RGBA values. Remember alpha premultiplication.
|
||||
|
||||
var colorTransparent = color.RGBA { A: 0 }
|
||||
var colorFocus = color.RGBA { R: 61, G: 128, B: 143, A: 255 }
|
||||
var colorInput = color.RGBA { R: 208, G: 203, B: 150, A: 255 }
|
||||
var colorCarved = color.RGBA { R: 151, G: 160, B: 150, A: 255 }
|
||||
var colorGutter = color.RGBA { R: 116, G: 132, B: 126, A: 255 }
|
||||
var colorShadow = color.RGBA { R: 57, G: 59, B: 57, A: 255 }
|
||||
var colorShade = color.RGBA { A: 128 }
|
||||
var colorInputShadow = color.RGBA { R: 143, G: 146, B: 91, A: 255 }
|
||||
var colorHighlight = color.RGBA { R: 207, G: 215, B: 210, A: 255 }
|
||||
var colorBackground = color.RGBA { R: 169, G: 171, B: 168, A: 255 }
|
||||
var colorCarvedPressed = color.RGBA { R: 129, G: 142, B: 137, A: 255 }
|
||||
var colorForeground = color.Black
|
||||
var colorOutline = color.Black
|
||||
var colorCalendarWeekdayHeader = color.RGBA { R: 194, G: 162, B: 132, A: 255 }
|
||||
var colorCalendarWeekend = color.RGBA { R: 165, G: 185, B: 120, A: 255 }
|
||||
var colorCalendarDay = color.RGBA { R: 194, G: 189, B: 132, A: 255 }
|
||||
var colorInactive = color.RGBA { R: 131, G: 147, B: 134, A: 255 }
|
||||
|
||||
var outline = tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: [4]color.Color {
|
||||
colorOutline,
|
||||
colorOutline,
|
||||
colorOutline,
|
||||
colorOutline,
|
||||
},
|
||||
}
|
||||
|
||||
var borderColorOutline = [4]color.Color { colorOutline, colorOutline, colorOutline, colorOutline }
|
||||
var borderColorEngraved = [4]color.Color { colorShadow, colorHighlight, colorHighlight, colorShadow }
|
||||
var borderColorLifted = [4]color.Color { colorHighlight, colorShadow, colorShadow, colorHighlight }
|
||||
var borderColorInput = [4]color.Color { colorInputShadow, colorInput, colorInput, colorInputShadow }
|
||||
var borderColorFocused = [4]color.Color { colorFocus, colorFocus, colorFocus, colorFocus }
|
||||
var borderColorShade = [4]color.Color { colorShade, colorShade, colorShade, colorShade }
|
||||
|
||||
//go:embed assets/atlas.png
|
||||
var atlasBytes []byte
|
||||
|
||||
// New returns Wintergreen, the default Tomo style. It is neutral-gray with
|
||||
// green and turquoise accents.
|
||||
func New () (*style.Style, event.Cookie) {
|
||||
atlasImage, _, err := image.Decode(bytes.NewReader(atlasBytes))
|
||||
if err != nil { panic(err) }
|
||||
atlasTexture := tomo.NewTexture(atlasImage)
|
||||
|
||||
textureCheckboxChecked := atlasTexture.SubTexture(image.Rect( 0, 0, 12, 11))
|
||||
// textureCorkboard := atlasTexture.SubTexture(image.Rect(16, 0, 28, 12))
|
||||
textureTearLine := atlasTexture.SubTexture(image.Rect(16, 12, 18, 13))
|
||||
textureHandleVertical := atlasTexture.SubTexture(image.Rect(28, 0, 29, 2))
|
||||
textureHandleHorizontal := atlasTexture.SubTexture(image.Rect(28, 0, 30, 1))
|
||||
|
||||
cookie := event.MultiCookie(atlasTexture)
|
||||
|
||||
rules := []style.Rule {
|
||||
// *.*
|
||||
style.Ru(style.AS (
|
||||
tomo.ATextColor (tomo.ColorForeground),
|
||||
tomo.ADotColor (tomo.ColorAccent ),
|
||||
tomo.AGap (8, 8 ),
|
||||
), tomo.R("", "")),
|
||||
|
||||
// *.Button
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
tomo.AttrPadding(tomo.I(4, 8)),
|
||||
tomo.AttrColor { Color: tomo.ColorRaised },
|
||||
), tomo.R("", "Button")),
|
||||
|
||||
// *.Button[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
},
|
||||
},
|
||||
), tomo.R("", "Button"), "focused"),
|
||||
|
||||
// *.Button[pressed]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
tomo.AttrPadding(tomo.I(5, 8, 4, 9)),
|
||||
tomo.AttrColor { Color: colorCarvedPressed },
|
||||
), tomo.R("", "Button"), "pressed"),
|
||||
|
||||
// *.TextInput
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorInput,
|
||||
}),
|
||||
tomo.AColor(colorInput),
|
||||
tomo.APadding(5, 4, 4, 5),
|
||||
), tomo.R("", "TextInput")),
|
||||
|
||||
// *.TextInput[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
}),
|
||||
), tomo.R("", "TextInput"), "focused"),
|
||||
|
||||
// *.TextView
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
}),
|
||||
tomo.AColor(tomo.ColorSunken),
|
||||
tomo.APadding(8),
|
||||
), tomo.R("", "TextView")),
|
||||
|
||||
// *.NumberInput
|
||||
style.Ru(style.AS (
|
||||
tomo.AGap(0, 0),
|
||||
), tomo.R("", "NumberInput")),
|
||||
|
||||
// *.Root
|
||||
style.Ru(style.AS (
|
||||
tomo.AGap(0, 0),
|
||||
), tomo.R("", "Root")),
|
||||
|
||||
// *.Root[menu]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
tomo.AttrColor { Color: tomo.ColorBackground },
|
||||
tomo.AttrGap { },
|
||||
), tomo.R("", "Root"), "menu"),
|
||||
|
||||
// *.Pegboard
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
}),
|
||||
tomo.AColor(tomo.ColorSunken),
|
||||
// tomo.ATexture(textureCorkboard),
|
||||
tomo.APadding(8),
|
||||
), tomo.R("", "Pegboard")),
|
||||
|
||||
// *.Segment
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
tomo.AttrColor { Color: tomo.ColorBackground },
|
||||
tomo.AttrPadding(tomo.I(8)),
|
||||
), tomo.R("", "Segment")),
|
||||
|
||||
// *.Segment[option]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrColor { Color: tomo.ColorSunken },
|
||||
tomo.AttrPadding(tomo.I(8)),
|
||||
), tomo.R("", "Segment"), "option"),
|
||||
|
||||
// *.Heading
|
||||
style.Ru(style.AS (
|
||||
tomo.AAlign(tomo.AlignMiddle, tomo.AlignMiddle),
|
||||
), tomo.R("", "Heading")),
|
||||
|
||||
// *.Heading
|
||||
style.Ru(style.AS (
|
||||
tomo.APadding(4, 8),
|
||||
), tomo.R("", "Heading"), "menu"),
|
||||
|
||||
// *.Separator
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
), tomo.R("", "Separator")),
|
||||
|
||||
// *.Slider
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
tomo.AttrColor { Color: colorGutter },
|
||||
tomo.AttrPadding(tomo.I(0, 1, 1, 0)),
|
||||
), tomo.R("", "Slider")),
|
||||
|
||||
// *.Slider[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
}),
|
||||
tomo.APadding(0),
|
||||
), tomo.R("", "Slider"), "focused"),
|
||||
|
||||
// *.Slider[horizontal]
|
||||
style.Ru(style.AS (
|
||||
tomo.AMinimumSize(48, 0),
|
||||
), tomo.R("", "Slider"), "horizontal"),
|
||||
|
||||
// *.Slider[vertical]
|
||||
style.Ru(style.AS (
|
||||
tomo.AMinimumSize(0, 48),
|
||||
), tomo.R("", "Slider"), "vertical"),
|
||||
|
||||
// *.SliderHandle
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: [4]color.Color {
|
||||
tomo.ColorRaised, tomo.ColorRaised,
|
||||
tomo.ColorRaised, tomo.ColorRaised,
|
||||
},
|
||||
}),
|
||||
tomo.AColor(nil),
|
||||
tomo.ATexture(textureHandleVertical),
|
||||
tomo.AMinimumSize(12, 12),
|
||||
), tomo.R("", "SliderHandle")),
|
||||
|
||||
// *.SliderHandle[horizontal]
|
||||
style.Ru(style.AS (
|
||||
tomo.ATexture(textureHandleHorizontal),
|
||||
), tomo.R("", "SliderHandle"), "horizontal"),
|
||||
|
||||
// *.Scrollbar
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
tomo.AttrColor { Color: colorGutter },
|
||||
tomo.AttrPadding(tomo.I(0, 1, 1, 0)),
|
||||
), tomo.R("", "Scrollbar")),
|
||||
|
||||
// *.Scrollbar[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
}),
|
||||
tomo.APadding(0),
|
||||
), tomo.R("", "Scrollbar"), "focused"),
|
||||
|
||||
// *.Scrollbar[horizontal]
|
||||
style.Ru(style.AS (
|
||||
tomo.AMinimumSize(48, 0),
|
||||
), tomo.R("", "Scrollbar"), "horizontal"),
|
||||
|
||||
// *.Scrollbar[vertical]
|
||||
style.Ru(style.AS (
|
||||
tomo.AMinimumSize(0, 48),
|
||||
), tomo.R("", "Scrollbar"), "vertical"),
|
||||
|
||||
// *.ScrollbarHandle
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: [4]color.Color {
|
||||
tomo.ColorRaised, tomo.ColorRaised,
|
||||
tomo.ColorRaised, tomo.ColorRaised,
|
||||
},
|
||||
}),
|
||||
tomo.AColor(nil),
|
||||
tomo.ATexture(textureHandleVertical),
|
||||
tomo.AMinimumSize(12, 12),
|
||||
), tomo.R("", "ScrollbarHandle")),
|
||||
|
||||
// *.ScrollbarHandle[horizontal]
|
||||
style.Ru(style.AS (
|
||||
tomo.ATexture(textureHandleHorizontal),
|
||||
), tomo.R("", "ScrollbarHandle"), "horizontal"),
|
||||
|
||||
// *.ScrollContainer
|
||||
style.Ru(style.AS (
|
||||
tomo.AGap(0, 0),
|
||||
), tomo.R("", "ScrollContainer")),
|
||||
|
||||
// *.Checkbox
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
}),
|
||||
tomo.AColor(tomo.ColorSunken),
|
||||
tomo.APadding(0, 1, 1, 0),
|
||||
tomo.AMinimumSize(19, 19),
|
||||
tomo.ATexture(nil),
|
||||
tomo.ATextureMode(tomo.TextureModeCenter),
|
||||
), tomo.R("", "Checkbox")),
|
||||
|
||||
// *.Checkbox[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
}),
|
||||
tomo.APadding(0),
|
||||
), tomo.R("", "Checkbox"), "focused"),
|
||||
|
||||
// *.Checkbox[checked]
|
||||
style.Ru(style.AS (
|
||||
tomo.ATexture(textureCheckboxChecked),
|
||||
), tomo.R("", "Checkbox"), "checked"),
|
||||
|
||||
// *.MenuItem
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrPadding(tomo.I(4)),
|
||||
tomo.AttrGap { X: 4, Y: 4 },
|
||||
tomo.AttrColor { Color: color.Transparent },
|
||||
), tomo.R("", "MenuItem")),
|
||||
|
||||
// *MenuItem[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrColor { Color: tomo.ColorAccent },
|
||||
), tomo.R("", "MenuItem"), "focused"),
|
||||
|
||||
// *.File
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrColor { Color: color.Transparent },
|
||||
), tomo.R("", "File")),
|
||||
|
||||
// *.File[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrColor { Color: tomo.ColorAccent },
|
||||
), tomo.R("", "File"), "focused"),
|
||||
|
||||
// *.TearLine
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
tomo.Border {
|
||||
Width: tomo.I(3),
|
||||
Color: [4]color.Color {
|
||||
color.Transparent,
|
||||
color.Transparent,
|
||||
color.Transparent,
|
||||
color.Transparent,
|
||||
},
|
||||
}),
|
||||
tomo.ATexture(textureTearLine),
|
||||
tomo.APadding(1, 0, 0, 1),
|
||||
), tomo.R("", "TearLine")),
|
||||
|
||||
// *.TearLine[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
tomo.Border {
|
||||
Width: tomo.I(3),
|
||||
Color: borderColorFocused,
|
||||
},
|
||||
},
|
||||
), tomo.R("", "TearLine"), "focused"),
|
||||
|
||||
// *.Calendar
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
tomo.Border {
|
||||
Width: tomo.I(0, 1, 1, 0),
|
||||
Color: borderColorShade,
|
||||
},
|
||||
outline,
|
||||
},
|
||||
tomo.AttrColor { Color: colorInput },
|
||||
tomo.AttrPadding(tomo.I(2)),
|
||||
tomo.AttrGap { X: 2, Y: 2 },
|
||||
), tomo.R("", "Calendar")),
|
||||
|
||||
// *.CalendarGrid
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrGap { X: 2, Y: 2 },
|
||||
), tomo.R("", "CalendarGrid")),
|
||||
|
||||
// *.CalendarWeekdayHeader
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrPadding(tomo.I(2)),
|
||||
tomo.AttrColor { Color: colorCalendarWeekdayHeader },
|
||||
), tomo.R("", "CalendarWeekdayHeader")),
|
||||
|
||||
// *.CalendarDay[weekday]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrPadding(tomo.I(2)),
|
||||
tomo.AttrMinimumSize { X: 32, Y: 32 },
|
||||
tomo.AttrColor { Color: colorCalendarDay },
|
||||
), tomo.R("", "CalendarDay"), "weekday"),
|
||||
|
||||
// *.CalendarDay[weekend]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrPadding(tomo.I(2)),
|
||||
tomo.AttrMinimumSize { X: 32, Y: 32 },
|
||||
tomo.AttrColor { Color: colorCalendarWeekend },
|
||||
), tomo.R("", "CalendarDay"), "weekend"),
|
||||
|
||||
// *.Notebook
|
||||
style.Ru(style.AS (
|
||||
tomo.AGap(0, 0),
|
||||
), tomo.R("", "Notebook")),
|
||||
|
||||
// *.PageWrapper
|
||||
style.Ru(style.AS (
|
||||
tomo.ABorder (
|
||||
tomo.Border {
|
||||
Width: tomo.I(0, 1, 1, 1),
|
||||
Color: borderColorOutline,
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(0, 1, 1, 1),
|
||||
Color: borderColorLifted,
|
||||
}),
|
||||
tomo.AColor(tomo.ColorBackground),
|
||||
tomo.APadding(8),
|
||||
), tomo.R("", "PageWrapper")),
|
||||
|
||||
// *.TabRow
|
||||
style.Ru(style.AS (
|
||||
tomo.AGap(0, 0),
|
||||
tomo.AttrPadding(tomo.I(1, 0, 0, 0)),
|
||||
), tomo.R("", "TabRow")),
|
||||
|
||||
// *.TabSpacer[right]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 0),
|
||||
Color: [4]color.Color {
|
||||
colorTransparent, colorTransparent,
|
||||
colorTransparent, colorTransparent,
|
||||
},
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(0, 0, 1, 0),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(0, 0, 1, 1),
|
||||
Color: borderColorOutline,
|
||||
},
|
||||
},
|
||||
tomo.AttrMinimumSize { X: 3 },
|
||||
), tomo.R("", "TabSpacer"), "right"),
|
||||
|
||||
// *.Tab
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 0),
|
||||
Color: [4]color.Color {
|
||||
colorTransparent, colorTransparent,
|
||||
colorTransparent, colorTransparent,
|
||||
},
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(0, 0, 1, 0),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 1, 1),
|
||||
Color: borderColorOutline,
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 1, 0, 1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
tomo.AttrPadding(tomo.I(4, 8, 4, 8)),
|
||||
tomo.AttrColor { Color: tomo.ColorRaised },
|
||||
), tomo.R("", "Tab")),
|
||||
|
||||
// *.Tab[active]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorOutline,
|
||||
},
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 1, 0, 1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
tomo.AttrPadding(tomo.I(4, 8, 7, 8)),
|
||||
tomo.AttrColor { Color: tomo.ColorBackground },
|
||||
), tomo.R("", "Tab"), "active"),
|
||||
|
||||
// *.Swatch
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
},
|
||||
tomo.AttrMinimumSize { X: 19, Y: 19 },
|
||||
), tomo.R("", "Swatch")),
|
||||
|
||||
// *.Swatch[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
},
|
||||
},
|
||||
), tomo.R("", "Swatch"), "focused"),
|
||||
|
||||
// *.ColorPickerMap
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
tomo.AttrColor { Color: tomo.ColorSunken },
|
||||
tomo.AttrMinimumSize { X: 128, Y: 128 },
|
||||
), tomo.R("", "ColorPickerMap")),
|
||||
|
||||
// *.Dropdown
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
tomo.AttrPadding(tomo.I(4, 8)),
|
||||
tomo.AttrColor { Color: tomo.ColorRaised },
|
||||
), tomo.R("", "Dropdown")),
|
||||
|
||||
// *.Dropdown[focused]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
},
|
||||
},
|
||||
), tomo.R("", "Dropdown"), "focused"),
|
||||
|
||||
// *.Dropdown[pressed]
|
||||
style.Ru(style.AS (
|
||||
tomo.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
tomo.AttrPadding(tomo.I(5, 8, 4, 9)),
|
||||
tomo.AttrColor { Color: colorCarvedPressed },
|
||||
), tomo.R("", "Dropdown"), "pressed"),
|
||||
}
|
||||
|
||||
return &style.Style {
|
||||
Rules: rules,
|
||||
Colors: map[tomo.Color] color.Color {
|
||||
tomo.ColorBackground: colorBackground,
|
||||
tomo.ColorForeground: colorForeground,
|
||||
tomo.ColorRaised: colorCarved,
|
||||
tomo.ColorSunken: colorCarved,
|
||||
tomo.ColorAccent: colorFocus,
|
||||
},
|
||||
}, cookie
|
||||
}
|
@ -1,21 +0,0 @@
|
||||
$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;
|
||||
}
|
@ -1,14 +0,0 @@
|
||||
$ColorBackground = #FFF;
|
||||
$ColorForeground = #000;
|
||||
$ColorRaised = #AAA;
|
||||
$ColorSunken = #888;
|
||||
$ColorAccent = #0FF;
|
||||
|
||||
*.* {
|
||||
Color: $ColorBackground;
|
||||
Border: $ColorForeground / 1;
|
||||
TextColor: $ColorForeground;
|
||||
DotColor: $ColorAccent;
|
||||
Padding: 2;
|
||||
}
|
||||
|
@ -1,399 +0,0 @@
|
||||
package tss
|
||||
|
||||
import "os"
|
||||
import "fmt"
|
||||
import "image"
|
||||
import "errors"
|
||||
import "image/color"
|
||||
import _ "image/png"
|
||||
import "path/filepath"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/backend/style"
|
||||
|
||||
type styleBuilder struct {
|
||||
sheet Sheet
|
||||
workingDir string
|
||||
textures map[string] canvas.TextureCloser
|
||||
}
|
||||
|
||||
// BuildStyle builds a Tomo style from the specified sheet. Resources associated
|
||||
// with it (such as textures) can be freed by closing the returned cookie.
|
||||
func BuildStyle (sheet Sheet) (*style.Style, event.Cookie, error) {
|
||||
builder := &styleBuilder {
|
||||
sheet: sheet,
|
||||
workingDir: filepath.Dir(sheet.Path),
|
||||
}
|
||||
return builder.build()
|
||||
}
|
||||
|
||||
func (this *styleBuilder) build () (*style.Style, event.Cookie, error) {
|
||||
// ensure the sheet is flattened (all vars are resolved)
|
||||
err := this.sheet.Flatten()
|
||||
if err != nil { return nil, nil, err }
|
||||
|
||||
getColor := func (name string) color.Color {
|
||||
if list, ok := this.sheet.Variables[name]; ok {
|
||||
if len(list) > 0 {
|
||||
if col, ok := list[0].(ValueColor); ok {
|
||||
return col
|
||||
}
|
||||
}
|
||||
}
|
||||
return color.RGBA { R: 255, B: 255, A: 255 }
|
||||
}
|
||||
|
||||
// construct style and get colors
|
||||
cookies := []event.Cookie { }
|
||||
sty := &style.Style {
|
||||
Rules: make([]style.Rule, len(this.sheet.Rules)),
|
||||
Colors: map[tomo.Color] color.Color {
|
||||
tomo.ColorBackground: getColor("ColorBackground"),
|
||||
tomo.ColorForeground: getColor("ColorForeground"),
|
||||
tomo.ColorRaised: getColor("ColorRaised"),
|
||||
tomo.ColorSunken: getColor("ColorSunken"),
|
||||
tomo.ColorAccent: getColor("ColorAccent"),
|
||||
},
|
||||
}
|
||||
|
||||
// build style rules from the sheet's rule slice
|
||||
for index, rule := range this.sheet.Rules {
|
||||
styleRule := style.Rule {
|
||||
Role: tomo.Role {
|
||||
Package: rule.Selector.Package,
|
||||
Object: rule.Selector.Object,
|
||||
},
|
||||
Tags: rule.Selector.Tags,
|
||||
Set: make(style.AttrSet),
|
||||
}
|
||||
for name, attr := range rule.Attrs {
|
||||
styleAttr, cookie, err := this.buildAttr(name, attr)
|
||||
if err != nil { return nil, nil, err }
|
||||
styleRule.Set.Add(styleAttr)
|
||||
if cookie != nil {
|
||||
cookies = append(cookies, cookie)
|
||||
}
|
||||
}
|
||||
sty.Rules[index] = styleRule
|
||||
}
|
||||
|
||||
// add each texture to the cookies list
|
||||
for _, texture := range this.textures {
|
||||
cookies = append(cookies, texture)
|
||||
}
|
||||
|
||||
return sty, event.MultiCookie(cookies...), nil
|
||||
}
|
||||
|
||||
func (this *styleBuilder) buildAttr (name string, attr []ValueList) (tomo.Attr, event.Cookie, error) {
|
||||
errWrongType := func () error {
|
||||
return errors.New(fmt.Sprintf("wrong type for %s attribute", name))
|
||||
}
|
||||
expectSingle := func () error {
|
||||
if len(attr) != 1 {
|
||||
return errors.New(fmt.Sprintf (
|
||||
"%s attribute requires exactly one value list",
|
||||
name))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
expectSingleSingle := func () error {
|
||||
err := expectSingle()
|
||||
if err != nil { return err }
|
||||
if len(attr[0]) != 1 {
|
||||
return errors.New(fmt.Sprintf (
|
||||
"%s attribute requires exactly one value",
|
||||
name))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
expectNumbers := func (list ValueList) error {
|
||||
for _, value := range list {
|
||||
if _, ok := value.(ValueNumber); ok { continue }
|
||||
return errWrongType()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
numbers := func (list ValueList) ([]int, error) {
|
||||
nums := make([]int, len(list))
|
||||
for index, value := range list {
|
||||
if value, ok := value.(ValueNumber); ok {
|
||||
nums[index] = int(value)
|
||||
continue
|
||||
}
|
||||
return nil, errWrongType()
|
||||
}
|
||||
return nums, nil
|
||||
}
|
||||
bools := func (list ValueList) ([]bool, error) {
|
||||
bools := make([]bool, len(list))
|
||||
for index, value := range list {
|
||||
if value, ok := value.(ValueKeyword); ok {
|
||||
switch value {
|
||||
case "true":
|
||||
bools[index] = true
|
||||
continue
|
||||
case "false":
|
||||
bools[index] = false
|
||||
continue
|
||||
}
|
||||
}
|
||||
return nil, errWrongType()
|
||||
}
|
||||
return bools, nil
|
||||
}
|
||||
point := func (list ValueList) (image.Point, error) {
|
||||
err := expectNumbers(list)
|
||||
if err != nil { return image.Point { }, err }
|
||||
|
||||
vector := image.Point { }
|
||||
switch len(attr[0]) {
|
||||
case 1:
|
||||
vector.X = int(list[0].(ValueNumber))
|
||||
vector.Y = int(list[0].(ValueNumber))
|
||||
case 2:
|
||||
vector.X = int(list[0].(ValueNumber))
|
||||
vector.Y = int(list[1].(ValueNumber))
|
||||
default:
|
||||
return image.Point { }, errors.New(fmt.Sprintf (
|
||||
"%s attribute requires exactly one or two values",
|
||||
name))
|
||||
}
|
||||
return vector, nil
|
||||
}
|
||||
|
||||
switch name {
|
||||
case "Color":
|
||||
err := expectSingleSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
if col, ok := attr[0][0].(ValueColor); ok {
|
||||
return tomo.AColor(col), nil, nil
|
||||
}
|
||||
return nil, nil, errWrongType()
|
||||
|
||||
case "Texture":
|
||||
err := expectSingleSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
if name, ok := attr[0][0].(ValueString); ok {
|
||||
texture, err := this.texture(string(name))
|
||||
if err != nil { return nil, nil, err }
|
||||
return tomo.ATexture(texture), nil, nil
|
||||
}
|
||||
return nil, nil, errWrongType()
|
||||
|
||||
case "TextureMode":
|
||||
err := expectSingleSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
if keyword, ok := attr[0][0].(ValueKeyword); ok {
|
||||
switch keyword {
|
||||
case "tile": return tomo.ATextureMode(tomo.TextureModeCenter), nil, nil
|
||||
case "center": return tomo.ATextureMode(tomo.TextureModeCenter), nil, nil
|
||||
}
|
||||
return nil, nil, errors.New(fmt.Sprintf (
|
||||
"unknown texture mode: %s",
|
||||
keyword))
|
||||
}
|
||||
return nil, nil, errWrongType()
|
||||
|
||||
case "Border":
|
||||
attrBorder, err := buildAttrBorder(attr)
|
||||
if err != nil { return nil, nil, err }
|
||||
return attrBorder, nil, nil
|
||||
|
||||
case "MinimumSize":
|
||||
err := expectSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
vector, err := point(attr[0])
|
||||
if err != nil { return nil, nil, err }
|
||||
return tomo.AttrMinimumSize(vector), nil, nil
|
||||
|
||||
case "Padding":
|
||||
err := expectSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
numbers, err := numbers(attr[0])
|
||||
if err != nil { return nil, nil, err }
|
||||
inset := tomo.Inset { }
|
||||
if !copyBorderValue(inset[:], numbers) {
|
||||
return nil, nil, errors.New(fmt.Sprintf (
|
||||
"%s attribute requires exactly one, two, or four values",
|
||||
name))
|
||||
}
|
||||
return tomo.AttrPadding(inset), nil, nil
|
||||
|
||||
case "Gap":
|
||||
err := expectSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
vector, err := point(attr[0])
|
||||
if err != nil { return nil, nil, err }
|
||||
return tomo.AttrGap(vector), nil, nil
|
||||
|
||||
case "TextColor":
|
||||
err := expectSingleSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
if col, ok := attr[0][0].(ValueColor); ok {
|
||||
return tomo.ATextColor(col), nil, nil
|
||||
}
|
||||
return nil, nil, errWrongType()
|
||||
|
||||
case "DotColor":
|
||||
err := expectSingleSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
if col, ok := attr[0][0].(ValueColor); ok {
|
||||
return tomo.ADotColor(col), nil, nil
|
||||
}
|
||||
return nil, nil, errWrongType()
|
||||
|
||||
case "Face":
|
||||
// TODO support weight, italic, slant
|
||||
err := expectSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
list := attr[0]
|
||||
if len(list) != 2 {
|
||||
return nil, nil, errors.New(fmt.Sprintf (
|
||||
"%s attribute requires exactly two values",
|
||||
name))
|
||||
}
|
||||
name, ok := list[0].(ValueString)
|
||||
if !ok { return nil, nil, errWrongType() }
|
||||
size, ok := list[1].(ValueNumber)
|
||||
if !ok { return nil, nil, errWrongType() }
|
||||
return tomo.AFace(tomo.Face {
|
||||
Font: string(name),
|
||||
Size: float64(size),
|
||||
}), nil, nil
|
||||
|
||||
case "Wrap":
|
||||
err := expectSingleSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
if value, ok := attr[0][0].(ValueKeyword); ok {
|
||||
switch value {
|
||||
case "true": return tomo.AWrap(true), nil, nil
|
||||
case "false": return tomo.AWrap(false), nil, nil
|
||||
}
|
||||
}
|
||||
return nil, nil, errWrongType()
|
||||
|
||||
case "Align":
|
||||
err := expectSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
list := attr[0]
|
||||
if len(list) != 2 {
|
||||
return nil, nil, errors.New(fmt.Sprintf (
|
||||
"%s attribute requires exactly two values",
|
||||
name))
|
||||
}
|
||||
aligns := [2]tomo.Align { }
|
||||
for index, value := range list {
|
||||
if keyword, ok := value.(ValueKeyword); ok {
|
||||
switch keyword {
|
||||
case "start": aligns[index] = tomo.AlignStart; continue
|
||||
case "middle": aligns[index] = tomo.AlignMiddle; continue
|
||||
case "end": aligns[index] = tomo.AlignEnd; continue
|
||||
case "even": aligns[index] = tomo.AlignEven; continue
|
||||
default: return nil, nil, errors.New(fmt.Sprintf (
|
||||
"unknown texture mode: %s",
|
||||
keyword))
|
||||
}
|
||||
}
|
||||
return nil, nil, errWrongType()
|
||||
}
|
||||
return tomo.AAlign(aligns[0], aligns[1]), nil, nil
|
||||
|
||||
case "Overflow":
|
||||
err := expectSingle()
|
||||
if err != nil { return nil, nil, err }
|
||||
bools, err := bools(attr[0])
|
||||
if err != nil { return nil, nil, err }
|
||||
if len(bools) != 2 {
|
||||
return nil, nil, errors.New(fmt.Sprintf (
|
||||
"%s attribute requires exactly two values",
|
||||
name))
|
||||
}
|
||||
return tomo.AOverflow(bools[0], bools[1]), nil, nil
|
||||
|
||||
case "Layout":
|
||||
// TODO allow use of some layouts in the objects package
|
||||
|
||||
default: return nil, nil, errors.New(fmt.Sprintf("unknown attribute name %s", name))
|
||||
}
|
||||
return nil, nil, errors.New(fmt.Sprintf("unimplemented attribute name %s", name))
|
||||
}
|
||||
|
||||
func (this *styleBuilder) texture (path string) (canvas.TextureCloser, error) {
|
||||
path = filepath.Join(this.workingDir, path)
|
||||
if texture, ok := this.textures[path]; ok {
|
||||
return texture, nil
|
||||
}
|
||||
file, err := os.Open(path)
|
||||
if err != nil { return nil, err }
|
||||
defer file.Close()
|
||||
rawImage, _, err := image.Decode(file)
|
||||
if err != nil { return nil, err }
|
||||
return tomo.NewTexture(rawImage), nil
|
||||
}
|
||||
|
||||
func buildAttrBorder (attr []ValueList) (tomo.Attr, error) {
|
||||
borders := make([]tomo.Border, len(attr))
|
||||
for index, list := range attr {
|
||||
colors := make([]color.Color, 0, len(list))
|
||||
sizes := make([]int, 0, len(list))
|
||||
|
||||
capturingSize := false
|
||||
for _, value := range list {
|
||||
if capturingSize {
|
||||
if value, ok := value.(ValueNumber); ok {
|
||||
sizes = append(sizes, int(value))
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
if _, ok := value.(ValueCut); ok {
|
||||
capturingSize = true
|
||||
continue
|
||||
}
|
||||
if value, ok := value.(ValueColor); ok {
|
||||
colors = append(colors, value)
|
||||
continue
|
||||
}
|
||||
}
|
||||
return nil, errors.New("malformed Border attribute value list")
|
||||
}
|
||||
|
||||
border := tomo.Border { }
|
||||
if !copyBorderValue(border.Width[:], sizes) {
|
||||
return nil, errors.New("malformed Border attribute width list")
|
||||
}
|
||||
if !copyBorderValue(border.Color[:], colors) {
|
||||
return nil, errors.New("malformed Border attribute color list")
|
||||
}
|
||||
borders[index] = border
|
||||
}
|
||||
|
||||
return tomo.ABorder(borders...), nil
|
||||
}
|
||||
|
||||
func copyBorderValue[T any, U ~[]T] (destination, source U) bool {
|
||||
if len(source) > len(destination) { return false }
|
||||
switch len(source) {
|
||||
case 1:
|
||||
destination[0] = source[0]
|
||||
destination[1] = source[0]
|
||||
destination[2] = source[0]
|
||||
destination[3] = source[0]
|
||||
return true
|
||||
case 2:
|
||||
destination[0] = source[0]
|
||||
destination[1] = source[1]
|
||||
destination[2] = source[0]
|
||||
destination[3] = source[1]
|
||||
return true
|
||||
case 4:
|
||||
destination[0] = source[0]
|
||||
destination[1] = source[1]
|
||||
destination[2] = source[2]
|
||||
destination[3] = source[3]
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
@ -1,17 +0,0 @@
|
||||
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) }
|
||||
}
|
@ -1,53 +0,0 @@
|
||||
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
|
||||
}
|
@ -1,363 +0,0 @@
|
||||
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'
|
||||
}
|
@ -1,66 +0,0 @@
|
||||
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,
|
||||
}
|
||||
}
|
@ -1,254 +0,0 @@
|
||||
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
|
||||
}
|
||||
}
|
@ -1,81 +0,0 @@
|
||||
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)
|
||||
}
|
@ -1,35 +0,0 @@
|
||||
# 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]*"
|
41
internal/theme/attribute.go
Normal file
@ -0,0 +1,41 @@
|
||||
package theme
|
||||
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "golang.org/x/image/font"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
|
||||
// Attr modifies one thing about an Objects's style.
|
||||
type Attr interface { attr () int }
|
||||
|
||||
// AttrColor sets the background color of an Objects.
|
||||
type AttrColor struct { color.Color }
|
||||
// AttrTexture sets the texture of an Objects to a named texture.
|
||||
type AttrTexture string
|
||||
// AttrBorder sets the border of an Objects.
|
||||
type AttrBorder []tomo.Border
|
||||
// AttrMinimumSize sets the minimum size of an Objects.
|
||||
type AttrMinimumSize image.Point
|
||||
// AttrPadding sets the inner padding of an Objects.
|
||||
type AttrPadding tomo.Inset
|
||||
// AttrGap sets the gap between child Objects, if the Object is a ContainerBox.
|
||||
type AttrGap image.Point
|
||||
// AttrTextColor sets the text color, if the Object is a TextBox.
|
||||
type AttrTextColor struct { color.Color }
|
||||
// AttrDotColor sets the text selection color, if the Object is a TextBox.
|
||||
type AttrDotColor struct { color.Color }
|
||||
// AttrFace sets the font face, if the Object is a TextBox.
|
||||
type AttrFace struct { font.Face }
|
||||
// AttrAlign sets the alignment, if the Object is a ContentBox.
|
||||
type AttrAlign struct { X, Y tomo.Align }
|
||||
|
||||
func (AttrColor) attr () int { return 0 }
|
||||
func (AttrTexture) attr () int { return 1 }
|
||||
func (AttrBorder) attr () int { return 2 }
|
||||
func (AttrMinimumSize) attr () int { return 3 }
|
||||
func (AttrPadding) attr () int { return 4 }
|
||||
func (AttrGap) attr () int { return 5 }
|
||||
func (AttrTextColor) attr () int { return 6 }
|
||||
func (AttrDotColor) attr () int { return 7 }
|
||||
func (AttrFace) attr () int { return 8 }
|
||||
func (AttrAlign) attr () int { return 9 }
|
BIN
internal/theme/default/assets/icons-large.png
Normal file
After Width: | Height: | Size: 8.3 KiB |
BIN
internal/theme/default/assets/icons-large.xcf
Normal file
BIN
internal/theme/default/assets/icons-small.png
Normal file
After Width: | Height: | Size: 6.9 KiB |
BIN
internal/theme/default/assets/icons-small.xcf
Normal file
Before Width: | Height: | Size: 3.5 KiB After Width: | Height: | Size: 3.5 KiB |
Before Width: | Height: | Size: 2.3 KiB After Width: | Height: | Size: 2.3 KiB |
21
internal/theme/default/default.go
Normal file
@ -0,0 +1,21 @@
|
||||
package defaultTheme
|
||||
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import dataTheme "git.tebibyte.media/tomo/nasin/internal/theme"
|
||||
|
||||
// Theme returns Wintergreen, the default Tomo tomo. It is neutral-gray with
|
||||
// green and turquoise accents.
|
||||
func Theme () *dataTheme.Theme {
|
||||
return &dataTheme.Theme {
|
||||
Colors: map[tomo.Color] color.Color {
|
||||
tomo.ColorBackground: colorBackground,
|
||||
tomo.ColorForeground: colorForeground,
|
||||
tomo.ColorRaised: colorCarved,
|
||||
tomo.ColorSunken: colorCarved,
|
||||
tomo.ColorAccent: colorFocus,
|
||||
},
|
||||
Rules: rules,
|
||||
IconTheme: &iconTheme { },
|
||||
}
|
||||
}
|
@ -1,4 +1,4 @@
|
||||
package fallbackIcons
|
||||
package defaultTheme
|
||||
|
||||
import "bytes"
|
||||
import "image"
|
||||
@ -6,37 +6,14 @@ import _ "embed"
|
||||
import _ "image/png"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/data"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/backend/style"
|
||||
import "git.tebibyte.media/tomo/nasin/internal/util"
|
||||
|
||||
//go:embed assets/icons-small.png
|
||||
var atlasSmallBytes []byte
|
||||
//go:embed assets/icons-large.png
|
||||
var atlasLargeBytes []byte
|
||||
|
||||
const (
|
||||
iconApplicationXGeneric = tomo.Icon("application/x-generic")
|
||||
iconApplicationXExecutable = tomo.Icon("application/x-executable")
|
||||
iconAudioXGeneric = tomo.Icon("audio/x-generic")
|
||||
iconFontXGeneric = tomo.Icon("font/x-generic")
|
||||
iconImageXGeneric = tomo.Icon("image/x-generic")
|
||||
iconModelXGeneric = tomo.Icon("model/x-generic")
|
||||
iconPackageXGeneric = tomo.Icon("package/x-generic")
|
||||
iconTextXGeneric = tomo.Icon("text/x-generic")
|
||||
iconTextHtml = tomo.Icon("text/html")
|
||||
iconTextXGenericTemplate = tomo.Icon("text/x-generic-template")
|
||||
iconTextXScript = tomo.Icon("text/x-script")
|
||||
iconVideoXGeneric = tomo.Icon("video/x-generic")
|
||||
iconXOfficeAddressBook = tomo.Icon("x-office-address-book")
|
||||
iconXOfficeCalendar = tomo.Icon("x-office-calendar")
|
||||
iconXOfficeDocument = tomo.Icon("x-office-document")
|
||||
iconXOfficePresentation = tomo.Icon("x-office-presentation")
|
||||
iconXOfficeSpreadsheet = tomo.Icon("x-office-spreadsheet")
|
||||
)
|
||||
|
||||
func generateSource (data []byte, width int) (canvas.TextureCloser, map[tomo.Icon] canvas.Texture) {
|
||||
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)
|
||||
@ -59,23 +36,7 @@ func generateSource (data []byte, width int) (canvas.TextureCloser, map[tomo.Ico
|
||||
}
|
||||
|
||||
col(tomo.IconUnknown)
|
||||
col(iconApplicationXGeneric)
|
||||
col(iconApplicationXExecutable)
|
||||
col(iconAudioXGeneric)
|
||||
col(iconFontXGeneric)
|
||||
col(iconImageXGeneric)
|
||||
col(iconModelXGeneric)
|
||||
col(iconPackageXGeneric)
|
||||
col(iconTextXGeneric)
|
||||
col(iconTextHtml)
|
||||
col(iconTextXGenericTemplate)
|
||||
col(iconTextXScript)
|
||||
col(iconVideoXGeneric)
|
||||
col(iconXOfficeAddressBook)
|
||||
col(iconXOfficeCalendar)
|
||||
col(iconXOfficeDocument)
|
||||
col(iconXOfficePresentation)
|
||||
col(iconXOfficeSpreadsheet)
|
||||
col(tomo.Icon("File"))
|
||||
|
||||
row()
|
||||
// actions
|
||||
@ -149,14 +110,9 @@ func generateSource (data []byte, width int) (canvas.TextureCloser, map[tomo.Ico
|
||||
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
|
||||
@ -354,6 +310,9 @@ func generateSource (data []byte, width int) (canvas.TextureCloser, map[tomo.Ico
|
||||
col(tomo.IconPlacePreferences)
|
||||
|
||||
row()
|
||||
// status: checkbox
|
||||
col(tomo.IconCheckboxChecked)
|
||||
col(tomo.IconCheckboxUnchecked)
|
||||
// status: appointments
|
||||
col(tomo.IconAppointmentMissed)
|
||||
col(tomo.IconAppointmentSoon)
|
||||
@ -449,29 +408,21 @@ func generateSource (data []byte, width int) (canvas.TextureCloser, map[tomo.Ico
|
||||
col(tomo.IconWeatherSnow)
|
||||
col(tomo.IconWeatherStorm)
|
||||
|
||||
return atlasTexture, source
|
||||
return source
|
||||
}
|
||||
|
||||
type iconSet struct {
|
||||
atlasSmall canvas.TextureCloser
|
||||
atlasLarge canvas.TextureCloser
|
||||
type iconTheme struct {
|
||||
texturesSmall map[tomo.Icon] canvas.Texture
|
||||
texturesLarge map[tomo.Icon] canvas.Texture
|
||||
}
|
||||
|
||||
// New creates a new fallback icon set.
|
||||
func New () (style.IconSet, event.Cookie) {
|
||||
iconSet := new(iconSet)
|
||||
return iconSet, iconSet
|
||||
}
|
||||
|
||||
func (this *iconSet) ensure () {
|
||||
func (this *iconTheme) ensure () {
|
||||
if this.texturesSmall != nil { return }
|
||||
this.atlasSmall, this.texturesSmall = generateSource(atlasSmallBytes, 16)
|
||||
this.atlasLarge, this.texturesLarge = generateSource(atlasLargeBytes, 32)
|
||||
this.texturesSmall = generateSource(atlasSmallBytes, 16)
|
||||
this.texturesLarge = generateSource(atlasLargeBytes, 32)
|
||||
}
|
||||
|
||||
func (this *iconSet) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.Texture {
|
||||
func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.Texture {
|
||||
if size == tomo.IconSizeSmall {
|
||||
return this.texturesSmall
|
||||
} else {
|
||||
@ -479,7 +430,7 @@ func (this *iconSet) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.Tex
|
||||
}
|
||||
}
|
||||
|
||||
func (this *iconSet) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
|
||||
func (this *iconTheme) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
|
||||
this.ensure()
|
||||
source := this.selectSource(size)
|
||||
if texture, ok := source[icon]; ok {
|
||||
@ -488,29 +439,12 @@ func (this *iconSet) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *iconSet) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
|
||||
func (this *iconTheme) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
|
||||
this.ensure()
|
||||
source := this.selectSource(size)
|
||||
|
||||
if icon, ok := source[tomo.Icon(mime.String())]; ok {
|
||||
return icon
|
||||
}
|
||||
|
||||
if mime == data.M("inode", "directory") {
|
||||
return source[tomo.IconPlaceDirectory]
|
||||
} else if icon, ok := source[tomo.Icon(util.GeneralizeXDGIconMimeType(mime).String())]; ok {
|
||||
return icon
|
||||
} else {
|
||||
return source[tomo.Icon(iconApplicationXGeneric)]
|
||||
return source[tomo.Icon("File")]
|
||||
}
|
||||
}
|
||||
|
||||
func (this *iconSet) Close () error {
|
||||
if this.atlasSmall != nil {
|
||||
this.atlasSmall.Close()
|
||||
}
|
||||
if this.atlasLarge != nil {
|
||||
this.atlasLarge.Close()
|
||||
}
|
||||
return nil
|
||||
}
|
298
internal/theme/default/style.go
Normal file
@ -0,0 +1,298 @@
|
||||
package defaultTheme
|
||||
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "golang.org/x/image/font/basicfont"
|
||||
import dataTheme "git.tebibyte.media/tomo/nasin/internal/theme"
|
||||
|
||||
var colorFocus = color.RGBA { R: 61, G: 128, B: 143, A: 255 }
|
||||
var colorInput = color.RGBA { R: 208, G: 203, B: 150, A: 255 }
|
||||
var colorCarved = color.RGBA { R: 151, G: 160, B: 150, A: 255 }
|
||||
var colorGutter = color.RGBA { R: 116, G: 132, B: 126, A: 255 }
|
||||
var colorShadow = color.RGBA { R: 57, G: 59, B: 57, A: 255 }
|
||||
var colorInputShadow = color.RGBA { R: 143, G: 146, B: 91, A: 255 }
|
||||
var colorHighlight = color.RGBA { R: 207, G: 215, B: 210, A: 255 }
|
||||
var colorBackground = color.RGBA { R: 169, G: 171, B: 168, A: 255 }
|
||||
var colorCarvedPressed = color.RGBA { R: 129, G: 142, B: 137, A: 255 }
|
||||
var colorForeground = color.Black
|
||||
var colorOutline = color.Black
|
||||
|
||||
var outline = tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: [4]color.Color {
|
||||
colorOutline,
|
||||
colorOutline,
|
||||
colorOutline,
|
||||
colorOutline,
|
||||
},
|
||||
}
|
||||
|
||||
var borderColorEngraved = [4]color.Color { colorShadow, colorHighlight, colorHighlight, colorShadow }
|
||||
var borderColorLifted = [4]color.Color { colorHighlight, colorShadow, colorShadow, colorHighlight }
|
||||
var borderColorInput = [4]color.Color { colorInputShadow, colorInput, colorInput, colorInputShadow }
|
||||
var borderColorFocused = [4]color.Color { colorFocus, colorFocus, colorFocus, colorFocus }
|
||||
|
||||
var rules = []dataTheme.Rule {
|
||||
// *.*[*]
|
||||
dataTheme.Rule {
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrFace { Face: basicfont.Face7x13 },
|
||||
dataTheme.AttrTextColor { Color: tomo.ColorForeground },
|
||||
dataTheme.AttrDotColor { Color: tomo.ColorAccent },
|
||||
dataTheme.AttrGap { X: 8, Y: 8 },
|
||||
),
|
||||
},
|
||||
|
||||
// *.Button[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Button", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrPadding(tomo.I(4, 8)),
|
||||
dataTheme.AttrColor { Color: tomo.ColorRaised },
|
||||
),
|
||||
Pressed: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrPadding(tomo.I(5, 8, 4, 9)),
|
||||
dataTheme.AttrColor { Color: colorCarvedPressed },
|
||||
),
|
||||
Focused: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrPadding(tomo.I(4, 8)),
|
||||
),
|
||||
},
|
||||
|
||||
// *.TextInput[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "TextInput", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorInput,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrColor { Color: colorInput },
|
||||
dataTheme.AttrPadding(tomo.I(5, 4, 4, 5)),
|
||||
),
|
||||
Focused: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
},
|
||||
},
|
||||
),
|
||||
},
|
||||
|
||||
// *.TextView[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "TextView", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrColor { Color: tomo.ColorSunken },
|
||||
dataTheme.AttrPadding(tomo.I(8)),
|
||||
),
|
||||
},
|
||||
|
||||
// *.NumberInput[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "NumberInput", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrGap { },
|
||||
),
|
||||
},
|
||||
|
||||
// *.Container[sunken]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Container", "sunken"),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrColor { Color: tomo.ColorSunken },
|
||||
dataTheme.AttrPadding(tomo.I(8)),
|
||||
),
|
||||
},
|
||||
|
||||
// *.Container[outer]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Container", "outer"),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrColor { Color: tomo.ColorBackground },
|
||||
dataTheme.AttrPadding(tomo.I(8)),
|
||||
),
|
||||
},
|
||||
|
||||
// *.Container[menu]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Container", "menu"),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrColor { Color: tomo.ColorBackground },
|
||||
dataTheme.AttrGap { },
|
||||
),
|
||||
},
|
||||
|
||||
// *.Heading[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Heading", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrAlign { X: tomo.AlignMiddle, Y: tomo.AlignMiddle },
|
||||
),
|
||||
},
|
||||
|
||||
// *.Separator[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Separator", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
),
|
||||
},
|
||||
|
||||
// *.Slider[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Slider", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrColor { Color: colorGutter },
|
||||
dataTheme.AttrPadding(tomo.I(0, 1, 1, 0)),
|
||||
),
|
||||
Focused: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrPadding(tomo.I(0)),
|
||||
),
|
||||
},
|
||||
|
||||
// *.Slider[horizontal]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Slider", "horizontal"),
|
||||
Default: dataTheme.AS(dataTheme.AttrMinimumSize { X: 48 }),
|
||||
},
|
||||
|
||||
// *.Slider[vertical]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Slider", "vertical"),
|
||||
Default: dataTheme.AS(dataTheme.AttrMinimumSize { Y: 48 }),
|
||||
},
|
||||
|
||||
// *.SliderHandle[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "SliderHandle", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorLifted,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrColor { Color: tomo.ColorRaised },
|
||||
dataTheme.AttrMinimumSize { X: 12, Y: 12, },
|
||||
),
|
||||
},
|
||||
|
||||
// *.Checkbox[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "Checkbox", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1, 0, 0, 1),
|
||||
Color: borderColorEngraved,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrColor { Color: tomo.ColorSunken },
|
||||
dataTheme.AttrPadding(tomo.I(0, 1, 1, 0)),
|
||||
dataTheme.AttrMinimumSize { X: 19, Y: 19 },
|
||||
),
|
||||
Focused: dataTheme.AS (
|
||||
dataTheme.AttrBorder {
|
||||
outline,
|
||||
tomo.Border {
|
||||
Width: tomo.I(1),
|
||||
Color: borderColorFocused,
|
||||
},
|
||||
},
|
||||
dataTheme.AttrPadding(tomo.I(0)),
|
||||
),
|
||||
},
|
||||
|
||||
// *.LabelCheckbox[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "LabelCheckbox", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrGap { X: 8, Y: 8 },
|
||||
),
|
||||
},
|
||||
|
||||
// *.MenuItem[*]
|
||||
dataTheme.Rule {
|
||||
Role: tomo.R("", "MenuItem", ""),
|
||||
Default: dataTheme.AS (
|
||||
dataTheme.AttrPadding(tomo.I(4)),
|
||||
dataTheme.AttrGap { X: 4, Y: 4 },
|
||||
dataTheme.AttrColor { Color: color.Transparent },
|
||||
),
|
||||
Hovered: dataTheme.AS (
|
||||
dataTheme.AttrColor { Color: tomo.ColorAccent },
|
||||
),
|
||||
Focused: dataTheme.AS (
|
||||
dataTheme.AttrColor { Color: tomo.ColorAccent },
|
||||
),
|
||||
},
|
||||
}
|
24
internal/theme/missing.go
Normal file
@ -0,0 +1,24 @@
|
||||
package theme
|
||||
|
||||
import "image"
|
||||
import "image/color"
|
||||
|
||||
type missingTexture int
|
||||
|
||||
func (texture missingTexture) ColorModel () color.Model {
|
||||
return color.RGBAModel
|
||||
}
|
||||
|
||||
func (texture missingTexture) Bounds () image.Rectangle {
|
||||
return image.Rect(0, 0, int(texture), int(texture))
|
||||
}
|
||||
|
||||
func (texture missingTexture) At (x, y int) color.Color {
|
||||
x /= 8
|
||||
y /= 8
|
||||
if (x + y) % 2 == 0 {
|
||||
return color.RGBA { R: 0xFF, B: 0xFF, A: 0xFF }
|
||||
} else {
|
||||
return color.RGBA { A: 0xFF }
|
||||
}
|
||||
}
|
267
internal/theme/theme.go
Normal file
@ -0,0 +1,267 @@
|
||||
// Package theme provides a data-driven theme implementation.
|
||||
package theme
|
||||
|
||||
import "image"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/data"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
import "git.tebibyte.media/tomo/tomo/input"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
|
||||
// this is CSS's bastard child
|
||||
|
||||
// Theme allows the use of data to define a visual style.
|
||||
type Theme struct {
|
||||
// Textures maps texture names to image textures.
|
||||
Textures map[string] image.Image
|
||||
textures map[string] canvas.TextureCloser // private texture cache
|
||||
missing canvas.TextureCloser // cache for "missing" texture
|
||||
|
||||
// Rules determines which styles get applied to which Objects.
|
||||
Rules []Rule
|
||||
|
||||
// Colors maps tomo.Color values to color.RGBA values.
|
||||
Colors map[tomo.Color] color.Color
|
||||
|
||||
// This type does not handle icons, and as such, a special icon theme
|
||||
// must be separately specified.
|
||||
IconTheme
|
||||
}
|
||||
|
||||
// IconTheme implements the part of tomo.Theme that handles icons.
|
||||
type IconTheme interface {
|
||||
// Icon returns a texture of the corresponding icon ID.
|
||||
Icon (tomo.Icon, tomo.IconSize) canvas.Texture
|
||||
// MimeIcon returns an icon corresponding to a MIME type.
|
||||
MimeIcon (data.Mime, tomo.IconSize) canvas.Texture
|
||||
}
|
||||
|
||||
// Rule describes under what circumstances should certain style attributes be
|
||||
// active.
|
||||
type Rule struct {
|
||||
Role tomo.Role
|
||||
Default AttrSet
|
||||
Hovered AttrSet
|
||||
Pressed AttrSet
|
||||
Focused AttrSet
|
||||
}
|
||||
|
||||
// AttrSet is a set of attributes wherein only one/zero of each attribute type
|
||||
// can exist. I deserve to be imprisoned for the way I made this work (look in
|
||||
// attribute.go). Its zero value can be used safely, and you can copy it if you
|
||||
// want, but it will point to the same set of attributes.
|
||||
type AttrSet struct {
|
||||
set map[int] Attr
|
||||
}
|
||||
|
||||
// AS builds an AttrSet out of a vararg list of Attr values.
|
||||
func AS (attrs ...Attr) AttrSet {
|
||||
set := AttrSet { }
|
||||
set.Add(attrs...)
|
||||
return set
|
||||
}
|
||||
|
||||
// Add adds attributes to the set.
|
||||
func (this *AttrSet) Add (attrs ...Attr) {
|
||||
this.ensure()
|
||||
for _, attr := range attrs {
|
||||
this.set[attr.attr()] = attr
|
||||
}
|
||||
}
|
||||
|
||||
// MergeUnder takes attributes from another set and adds them if they don't
|
||||
// already exist in this one.
|
||||
func (this *AttrSet) MergeUnder (other AttrSet) {
|
||||
this.ensure()
|
||||
if other.set == nil { return }
|
||||
for _, attr := range other.set {
|
||||
if _, exists := this.set[attr.attr()]; !exists {
|
||||
this.Add(attr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MergeOver takes attributes from another set and adds them, overriding this
|
||||
// one.
|
||||
func (this *AttrSet) MergeOver (other AttrSet) {
|
||||
this.ensure()
|
||||
if other.set == nil { return }
|
||||
for _, attr := range other.set {
|
||||
this.Add(attr)
|
||||
}
|
||||
}
|
||||
|
||||
func (this *AttrSet) ensure () {
|
||||
if this.set == nil { this.set = make(map[int] Attr) }
|
||||
}
|
||||
|
||||
func (this *Theme) execute (object tomo.Object, set AttrSet) {
|
||||
box := object.GetBox()
|
||||
|
||||
for _, attr := range set.set {
|
||||
switch attr := attr.(type) {
|
||||
case AttrColor:
|
||||
box.SetColor(attr.Color)
|
||||
case AttrTexture:
|
||||
box.SetTextureTile(this.texture(string(attr)))
|
||||
case AttrBorder:
|
||||
box.SetBorder([]tomo.Border(attr)...)
|
||||
case AttrMinimumSize:
|
||||
box.SetMinimumSize(image.Point(attr))
|
||||
case AttrPadding:
|
||||
box.SetPadding(tomo.Inset(attr))
|
||||
case AttrGap:
|
||||
if box, ok := box.(tomo.ContainerBox); ok {
|
||||
box.SetGap(image.Point(attr))
|
||||
}
|
||||
case AttrTextColor:
|
||||
if box, ok := box.(tomo.TextBox); ok {
|
||||
box.SetTextColor(attr.Color)
|
||||
}
|
||||
case AttrDotColor:
|
||||
if box, ok := box.(tomo.TextBox); ok {
|
||||
box.SetDotColor(attr.Color)
|
||||
}
|
||||
case AttrFace:
|
||||
if box, ok := box.(tomo.TextBox); ok {
|
||||
box.SetFace(attr)
|
||||
}
|
||||
case AttrAlign:
|
||||
if box, ok := box.(tomo.ContentBox); ok {
|
||||
box.SetAlign(attr.X, attr.Y)
|
||||
}
|
||||
default:
|
||||
panic("bug: nasin/internal/tomo.Theme: unexpected attribute")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (this *Theme) texture (name string) canvas.Texture {
|
||||
this.ensureTextureCache()
|
||||
if texture, ok := this.textures[name]; ok {
|
||||
return texture
|
||||
}
|
||||
if this.Textures == nil {
|
||||
if source, ok := this.Textures[name]; ok {
|
||||
texture := tomo.NewTexture(source)
|
||||
this.textures[name] = texture
|
||||
return texture
|
||||
}
|
||||
}
|
||||
return this.missingTexture()
|
||||
}
|
||||
|
||||
func (this *Theme) missingTexture () canvas.Texture {
|
||||
if this.missing == nil {
|
||||
this.missing = tomo.NewTexture(missingTexture(16))
|
||||
}
|
||||
return this.missing
|
||||
}
|
||||
|
||||
func (this *Theme) ensureTextureCache () {
|
||||
if this.textures == nil { this.textures = make(map[string] canvas.TextureCloser) }
|
||||
}
|
||||
|
||||
// setsFor builds flattened attr sets for a specific role based on the rules list
|
||||
func (this *Theme) setsFor (role tomo.Role) (defaul, hovered, pressed, focused AttrSet) {
|
||||
for _, current := range this.Rules {
|
||||
// check for a match
|
||||
packageMatch := current.Role.Package == role.Package || current.Role.Package == ""
|
||||
objectMatch := current.Role.Object == role.Object || current.Role.Object == ""
|
||||
variantMatch := current.Role.Variant == role.Variant || current.Role.Variant == ""
|
||||
if packageMatch && objectMatch && variantMatch {
|
||||
// if found, merge and override
|
||||
defaul.MergeOver(current.Default)
|
||||
hovered.MergeOver(current.Hovered)
|
||||
pressed.MergeOver(current.Pressed)
|
||||
focused.MergeOver(current.Focused)
|
||||
}
|
||||
}
|
||||
|
||||
// hovered and pressed are mutually exclusive states, so we compress
|
||||
// them with the default state.
|
||||
hovered.MergeUnder(defaul)
|
||||
pressed.MergeUnder(defaul)
|
||||
return defaul, hovered, pressed, focused
|
||||
}
|
||||
|
||||
func (this *Theme) Apply (object tomo.Object, role tomo.Role) event.Cookie {
|
||||
pressed := false
|
||||
hovered := false
|
||||
box := object.GetBox()
|
||||
|
||||
defaultSet, hoveredSet, pressedSet, focusedSet := this.setsFor(role)
|
||||
|
||||
updateStyle := func () {
|
||||
if pressed {
|
||||
this.execute(object, pressedSet)
|
||||
} else if hovered {
|
||||
this.execute(object, hoveredSet)
|
||||
} else {
|
||||
this.execute(object, defaultSet)
|
||||
}
|
||||
if box.Focused() && !pressed {
|
||||
this.execute(object, focusedSet)
|
||||
}
|
||||
}
|
||||
updateStyle()
|
||||
|
||||
return event.MultiCookie (
|
||||
box.OnFocusEnter(updateStyle),
|
||||
box.OnFocusLeave(updateStyle),
|
||||
box.OnMouseDown(func (button input.Button) {
|
||||
if button != input.ButtonLeft { return }
|
||||
pressed = true
|
||||
updateStyle()
|
||||
}),
|
||||
box.OnMouseUp(func (button input.Button) {
|
||||
if button != input.ButtonLeft { return }
|
||||
pressed = false
|
||||
updateStyle()
|
||||
}),
|
||||
box.OnMouseEnter(func () {
|
||||
hovered = true
|
||||
updateStyle()
|
||||
}),
|
||||
box.OnMouseLeave(func () {
|
||||
hovered = false
|
||||
updateStyle()
|
||||
}))
|
||||
|
||||
}
|
||||
|
||||
func (this *Theme) RGBA (c tomo.Color) (r, g, b, a uint32) {
|
||||
if this.Colors == nil { return 0xFFFF, 0, 0xFFFF, 0xFFFF }
|
||||
color, ok := this.Colors[c]
|
||||
if !ok { return 0xFFFF, 0, 0xFFFF, 0xFFFF }
|
||||
return color.RGBA()
|
||||
}
|
||||
|
||||
func (this *Theme) Icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
|
||||
if this.IconTheme == nil {
|
||||
return this.missingTexture()
|
||||
} else {
|
||||
return this.IconTheme.Icon(icon, size)
|
||||
}
|
||||
}
|
||||
|
||||
func (this *Theme) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Texture {
|
||||
if this.IconTheme == nil {
|
||||
return this.missingTexture()
|
||||
} else {
|
||||
return this.IconTheme.MimeIcon(mime, size)
|
||||
}
|
||||
}
|
||||
|
||||
// Close closes all cached textures this theme has open. Do not call this while
|
||||
// the theme is in use.
|
||||
func (this *Theme) Close () error {
|
||||
this.missing.Close()
|
||||
this.missing = nil
|
||||
for _, texture := range this.textures {
|
||||
texture.Close()
|
||||
}
|
||||
this.textures = nil
|
||||
return nil
|
||||
}
|
@ -8,37 +8,35 @@ 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/event"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/backend/style"
|
||||
import "git.tebibyte.media/tomo/nasin/internal/util"
|
||||
import xdgIconTheme "git.tebibyte.media/tomo/xdg/icon-theme"
|
||||
import "git.tebibyte.media/tomo/tomo/data"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/nasin/internal/theme"
|
||||
|
||||
type iconTheme struct {
|
||||
xdg xdgIconTheme.Theme
|
||||
fallback style.IconSet
|
||||
texturesSmall map[tomo.Icon] canvas.TextureCloser
|
||||
texturesMedium map[tomo.Icon] canvas.TextureCloser
|
||||
texturesLarge map[tomo.Icon] canvas.TextureCloser
|
||||
fallback theme.IconTheme
|
||||
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, event.Cookie, error) {
|
||||
func FindThemeWarn (name string, fallback theme.IconTheme, path ...string) (theme.IconTheme, error) {
|
||||
this := &iconTheme {
|
||||
fallback: fallback,
|
||||
texturesLarge: make(map[tomo.Icon] canvas.TextureCloser),
|
||||
texturesMedium: make(map[tomo.Icon] canvas.TextureCloser),
|
||||
texturesSmall: make(map[tomo.Icon] canvas.TextureCloser),
|
||||
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, nil, err }
|
||||
if err != nil { return nil, err }
|
||||
this.xdg = xdg
|
||||
|
||||
return this, this, nil
|
||||
return this, nil
|
||||
}
|
||||
|
||||
func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.TextureCloser {
|
||||
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
|
||||
@ -46,7 +44,7 @@ func (this *iconTheme) selectSource (size tomo.IconSize) map[tomo.Icon] canvas.T
|
||||
}
|
||||
}
|
||||
|
||||
func (this *iconTheme) xdgIcon (name string, size tomo.IconSize) (canvas.TextureCloser, bool) {
|
||||
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)
|
||||
@ -56,14 +54,14 @@ func (this *iconTheme) xdgIcon (name string, size tomo.IconSize) (canvas.Texture
|
||||
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)
|
||||
log.Println("nasin: icon file '%s' is inaccessible: %v", 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)
|
||||
log.Println("nasin: icon file '%s' is broken: %v", icon.Path, err)
|
||||
return nil, false
|
||||
}
|
||||
|
||||
@ -101,21 +99,7 @@ func (this *iconTheme) MimeIcon (mime data.Mime, size tomo.IconSize) canvas.Text
|
||||
}
|
||||
}
|
||||
|
||||
func (this *iconTheme) Close () error {
|
||||
closeAllIn := func (mp map[tomo.Icon] canvas.TextureCloser) {
|
||||
for _, texture := range mp {
|
||||
if texture != nil {
|
||||
texture.Close()
|
||||
}
|
||||
}
|
||||
}
|
||||
closeAllIn(this.texturesSmall)
|
||||
closeAllIn(this.texturesMedium)
|
||||
closeAllIn(this.texturesLarge)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *iconTheme) icon (icon tomo.Icon, size tomo.IconSize) canvas.TextureCloser {
|
||||
func (this *iconTheme) icon (icon tomo.Icon, size tomo.IconSize) canvas.Texture {
|
||||
if texture, ok := this.xdgIcon(XdgIconName(icon), size); ok {
|
||||
return texture
|
||||
}
|
||||
@ -125,11 +109,11 @@ func (this *iconTheme) icon (icon tomo.Icon, size tomo.IconSize) canvas.TextureC
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *iconTheme) mimeIcon (mime data.Mime, size tomo.IconSize) canvas.TextureCloser {
|
||||
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(util.GeneralizeXDGIconMimeType(mime)), size); ok {
|
||||
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 {
|
||||
@ -182,6 +166,13 @@ 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 {
|
@ -1,10 +0,0 @@
|
||||
package util
|
||||
|
||||
import "git.tebibyte.media/tomo/tomo/data"
|
||||
|
||||
func GeneralizeXDGIconMimeType (mime data.Mime) data.Mime {
|
||||
// FIXME make this more accurate
|
||||
// https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
|
||||
mime.Subtype = "x-generic"
|
||||
return mime
|
||||
}
|
33
manager.go
@ -1,33 +0,0 @@
|
||||
package nasin
|
||||
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
|
||||
var manager struct {
|
||||
count int
|
||||
}
|
||||
|
||||
// WaitFor ensures that the application will stay running while the given window
|
||||
// is open.
|
||||
func WaitFor (window tomo.Window) event.Cookie {
|
||||
manager.count ++
|
||||
|
||||
isManaged := true
|
||||
handleClose := func () {
|
||||
if !isManaged { return }
|
||||
isManaged = false
|
||||
manager.count --
|
||||
if manager.count < 1 {
|
||||
tomo.Stop()
|
||||
}
|
||||
}
|
||||
|
||||
handleWaitClose := func () error {
|
||||
handleClose();
|
||||
return nil
|
||||
}
|
||||
|
||||
return event.MultiCookie (
|
||||
window.OnClose(handleClose),
|
||||
event.FuncCookie(handleWaitClose))
|
||||
}
|
224
path.go
@ -1,58 +1,190 @@
|
||||
package nasin
|
||||
|
||||
import "io"
|
||||
import "os"
|
||||
import "io/fs"
|
||||
import "strings"
|
||||
import "path/filepath"
|
||||
|
||||
// ApplicationUserDataDir returns the directory path where an application can
|
||||
// store its user data files. If the directory does not exist, it will be
|
||||
// created.
|
||||
func ApplicationUserDataDir (app ApplicationDescription) (string, error) {
|
||||
return userMkdirAll(app.ID, userDataDir)
|
||||
// FS is Tomo's implementation of fs.FS. It provides access to a specific part
|
||||
// of the filesystem.
|
||||
type FS struct {
|
||||
path string
|
||||
}
|
||||
|
||||
// ApplicationSystemDataDirs returns a list of directory paths where an
|
||||
// application can look for its system-level data files. Directories returned
|
||||
// by this function may or may not actually exist. This function may return an
|
||||
// empty slice on some platforms.
|
||||
func ApplicationSystemDataDirs (app ApplicationDescription) ([]string, error) {
|
||||
return systemDirs(app.ID, systemDataDirs)
|
||||
// FileWriter is a writable version of fs.File.
|
||||
type FileWriter interface {
|
||||
fs.File
|
||||
io.Writer
|
||||
}
|
||||
|
||||
// ApplicationUserConfigDir returns the directory path where an application can
|
||||
// store its user configuration files.
|
||||
func ApplicationUserConfigDir (app ApplicationDescription) (string, error) {
|
||||
return userMkdirAll(app.ID, userConfigDir)
|
||||
}
|
||||
|
||||
// ApplicationSystemDataDirs returns a list of directory paths where an
|
||||
// application can look for its system-level configuration files. Directories
|
||||
// returned by this function may or may not actually exist. This function may
|
||||
// return an empty slice on some platforms.
|
||||
func ApplicationSystemConfigDirs (app ApplicationDescription) ([]string, error) {
|
||||
return systemDirs(app.ID, systemConfigDirs)
|
||||
}
|
||||
|
||||
// ApplicationUserCacheDir returns the directory path where an application can
|
||||
// store its user cache files.
|
||||
func ApplicationUserCacheDir (app ApplicationDescription) (string, error) {
|
||||
return userMkdirAll(app.ID, userCacheDir)
|
||||
}
|
||||
|
||||
func userMkdirAll (sub string, getter func () (string, error)) (string, error) {
|
||||
path, err := getter()
|
||||
if err != nil { return "", err }
|
||||
path = filepath.Join(path, sub)
|
||||
err = os.MkdirAll(path, 0700)
|
||||
if err != nil { return "", err }
|
||||
return path, nil
|
||||
}
|
||||
|
||||
func systemDirs (sub string, getter func () ([]string, error)) ([]string, error) {
|
||||
paths, err := getter()
|
||||
// ApplicationUserDataFS returns an FS that an application can use to store user
|
||||
// data files.
|
||||
func ApplicationUserDataFS (app ApplicationDescription) (*FS, error) {
|
||||
dataDir, err := userDataDir()
|
||||
if err != nil { return nil, err }
|
||||
specificPaths := make([]string, len(paths))
|
||||
for index, path := range paths {
|
||||
specificPaths[index] = filepath.Join(path, sub)
|
||||
return appFs(dataDir, app)
|
||||
}
|
||||
return specificPaths, nil
|
||||
|
||||
// ApplicationUserConfigFS returns an FS that an application can use to store
|
||||
// user configuration files.
|
||||
func ApplicationUserConfigFS (app ApplicationDescription) (*FS, error) {
|
||||
configDir, err := userConfigDir()
|
||||
if err != nil { return nil, err }
|
||||
return appFs(configDir, app)
|
||||
}
|
||||
|
||||
// ApplicationUserCacheFS returns an FS that an application can use to store
|
||||
// user cache files.
|
||||
func ApplicationUserCacheFS (app ApplicationDescription) (*FS, error) {
|
||||
cacheDir, err := userCacheDir()
|
||||
if err != nil { return nil, err }
|
||||
return appFs(cacheDir, app)
|
||||
}
|
||||
|
||||
func pathErr (op, path string, err error) error {
|
||||
return &fs.PathError {
|
||||
Op: op,
|
||||
Path: path,
|
||||
Err: err,
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
@ -7,18 +7,10 @@ func userDataDir () (string, error) {
|
||||
return basedir.DataHome()
|
||||
}
|
||||
|
||||
func systemDataDirs () ([]string, error) {
|
||||
return basedir.DataDirs()
|
||||
}
|
||||
|
||||
func userConfigDir () (string, error) {
|
||||
return basedir.ConfigHome()
|
||||
}
|
||||
|
||||
func systemConfigDirs () ([]string, error) {
|
||||
return basedir.ConfigDirs()
|
||||
}
|
||||
|
||||
func userCacheDir () (string, error) {
|
||||
return basedir.CacheHome()
|
||||
}
|
||||
|